//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS QConnect service.
///
///    Amazon Q actions     Amazon Q data types      Powered by Amazon Bedrock: Amazon Web Services implements automated abuse detection. Because Amazon Q in Connect is built on Amazon Bedrock, users can take full advantage of the controls implemented in Amazon Bedrock to enforce safety, security, and the responsible use of artificial intelligence (AI).  Amazon Q in Connect is a generative AI customer service assistant. It is an LLM-enhanced evolution of Amazon Connect Wisdom that delivers real-time recommendations to help contact center agents resolve customer issues quickly and accurately. Amazon Q in Connect automatically detects customer intent during calls and chats using conversational analytics and natural language understanding (NLU). It then provides agents with immediate, real-time generative responses and suggested actions, and links to relevant documents and articles. Agents can also query Amazon Q in Connect directly using natural language or keywords to answer customer requests. Use the Amazon Q in Connect APIs to create an assistant and a knowledge base, for example, or manage content by uploading custom files. For more information, see Use Amazon Q in Connect for generative AI powered agent assistance in real-time in the Amazon Connect Administrator Guide.
public struct QConnect: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the QConnect client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "QConnect",
            serviceIdentifier: "wisdom",
            serviceProtocol: .restjson,
            apiVersion: "2020-10-19",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: QConnectErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "ca-central-1": "wisdom-fips.ca-central-1.amazonaws.com",
            "us-east-1": "wisdom-fips.us-east-1.amazonaws.com",
            "us-west-2": "wisdom-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Activates a specific version of the Amazon Q in Connect message template. After the version is activated, the previous active version will be deactivated automatically. You can use the $ACTIVE_VERSION qualifier later to reference the version that is in active status.
    @Sendable
    @inlinable
    public func activateMessageTemplate(_ input: ActivateMessageTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ActivateMessageTemplateResponse {
        try await self.client.execute(
            operation: "ActivateMessageTemplate", 
            path: "/knowledgeBases/{knowledgeBaseId}/messageTemplates/{messageTemplateId}/activate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Activates a specific version of the Amazon Q in Connect message template. After the version is activated, the previous active version will be deactivated automatically. You can use the $ACTIVE_VERSION qualifier later to reference the version that is in active status.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - messageTemplateId: The identifier of the message template. Can be either the ID or the ARN. It cannot contain any qualifier.
    ///   - versionNumber: The version number of the message template version to activate.
    ///   - logger: Logger use during operation
    @inlinable
    public func activateMessageTemplate(
        knowledgeBaseId: String,
        messageTemplateId: String,
        versionNumber: Int64,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ActivateMessageTemplateResponse {
        let input = ActivateMessageTemplateRequest(
            knowledgeBaseId: knowledgeBaseId, 
            messageTemplateId: messageTemplateId, 
            versionNumber: versionNumber
        )
        return try await self.activateMessageTemplate(input, logger: logger)
    }

    /// Creates an Amazon Q in Connect AI Agent.
    @Sendable
    @inlinable
    public func createAIAgent(_ input: CreateAIAgentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAIAgentResponse {
        try await self.client.execute(
            operation: "CreateAIAgent", 
            path: "/assistants/{assistantId}/aiagents", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Q in Connect AI Agent.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs..
    ///   - configuration: The configuration of the AI Agent.
    ///   - description: The description of the AI Agent.
    ///   - name: The name of the AI Agent.
    ///   - tags: The tags used to organize, track, or control access for this resource.
    ///   - type: The type of the AI Agent.
    ///   - visibilityStatus: The visibility status of the AI Agent.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAIAgent(
        assistantId: String,
        clientToken: String? = CreateAIAgentRequest.idempotencyToken(),
        configuration: AIAgentConfiguration,
        description: String? = nil,
        name: String,
        tags: [String: String]? = nil,
        type: AIAgentType,
        visibilityStatus: VisibilityStatus,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAIAgentResponse {
        let input = CreateAIAgentRequest(
            assistantId: assistantId, 
            clientToken: clientToken, 
            configuration: configuration, 
            description: description, 
            name: name, 
            tags: tags, 
            type: type, 
            visibilityStatus: visibilityStatus
        )
        return try await self.createAIAgent(input, logger: logger)
    }

    /// Creates and Amazon Q in Connect AI Agent version.
    @Sendable
    @inlinable
    public func createAIAgentVersion(_ input: CreateAIAgentVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAIAgentVersionResponse {
        try await self.client.execute(
            operation: "CreateAIAgentVersion", 
            path: "/assistants/{assistantId}/aiagents/{aiAgentId}/versions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates and Amazon Q in Connect AI Agent version.
    ///
    /// Parameters:
    ///   - aiAgentId: The identifier of the Amazon Q in Connect AI Agent.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs..
    ///   - modifiedTime: The modification time of the AI Agent should be tracked for version creation. This field should be specified to avoid version creation when simultaneous update to the underlying AI Agent are possible. The value should be the modifiedTime returned from the request to create or update an AI Agent so that version creation can fail if an update to the AI Agent post the specified modification time has been made.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAIAgentVersion(
        aiAgentId: String,
        assistantId: String,
        clientToken: String? = CreateAIAgentVersionRequest.idempotencyToken(),
        modifiedTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAIAgentVersionResponse {
        let input = CreateAIAgentVersionRequest(
            aiAgentId: aiAgentId, 
            assistantId: assistantId, 
            clientToken: clientToken, 
            modifiedTime: modifiedTime
        )
        return try await self.createAIAgentVersion(input, logger: logger)
    }

    /// Creates an Amazon Q in Connect AI Guardrail.
    @Sendable
    @inlinable
    public func createAIGuardrail(_ input: CreateAIGuardrailRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAIGuardrailResponse {
        try await self.client.execute(
            operation: "CreateAIGuardrail", 
            path: "/assistants/{assistantId}/aiguardrails", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Q in Connect AI Guardrail.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - blockedInputMessaging: The message to return when the AI Guardrail blocks a prompt.
    ///   - blockedOutputsMessaging: The message to return when the AI Guardrail blocks a model response.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs..
    ///   - contentPolicyConfig: The content filter policies to configure for the AI Guardrail.
    ///   - contextualGroundingPolicyConfig: The contextual grounding policy configuration used to create an AI Guardrail.
    ///   - description: A description of the AI Guardrail.
    ///   - name: The name of the AI Guardrail.
    ///   - sensitiveInformationPolicyConfig: The sensitive information policy to configure for the AI Guardrail.
    ///   - tags: The tags used to organize, track, or control access for this resource.
    ///   - topicPolicyConfig: The topic policies to configure for the AI Guardrail.
    ///   - visibilityStatus: The visibility status of the AI Guardrail.
    ///   - wordPolicyConfig: The word policy you configure for the AI Guardrail.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAIGuardrail(
        assistantId: String,
        blockedInputMessaging: String,
        blockedOutputsMessaging: String,
        clientToken: String? = CreateAIGuardrailRequest.idempotencyToken(),
        contentPolicyConfig: AIGuardrailContentPolicyConfig? = nil,
        contextualGroundingPolicyConfig: AIGuardrailContextualGroundingPolicyConfig? = nil,
        description: String? = nil,
        name: String,
        sensitiveInformationPolicyConfig: AIGuardrailSensitiveInformationPolicyConfig? = nil,
        tags: [String: String]? = nil,
        topicPolicyConfig: AIGuardrailTopicPolicyConfig? = nil,
        visibilityStatus: VisibilityStatus,
        wordPolicyConfig: AIGuardrailWordPolicyConfig? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAIGuardrailResponse {
        let input = CreateAIGuardrailRequest(
            assistantId: assistantId, 
            blockedInputMessaging: blockedInputMessaging, 
            blockedOutputsMessaging: blockedOutputsMessaging, 
            clientToken: clientToken, 
            contentPolicyConfig: contentPolicyConfig, 
            contextualGroundingPolicyConfig: contextualGroundingPolicyConfig, 
            description: description, 
            name: name, 
            sensitiveInformationPolicyConfig: sensitiveInformationPolicyConfig, 
            tags: tags, 
            topicPolicyConfig: topicPolicyConfig, 
            visibilityStatus: visibilityStatus, 
            wordPolicyConfig: wordPolicyConfig
        )
        return try await self.createAIGuardrail(input, logger: logger)
    }

    /// Creates an Amazon Q in Connect AI Guardrail version.
    @Sendable
    @inlinable
    public func createAIGuardrailVersion(_ input: CreateAIGuardrailVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAIGuardrailVersionResponse {
        try await self.client.execute(
            operation: "CreateAIGuardrailVersion", 
            path: "/assistants/{assistantId}/aiguardrails/{aiGuardrailId}/versions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Q in Connect AI Guardrail version.
    ///
    /// Parameters:
    ///   - aiGuardrailId: The identifier of the Amazon Q in Connect AI Guardrail.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs..
    ///   - modifiedTime: The time the AI Guardrail was last modified.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAIGuardrailVersion(
        aiGuardrailId: String,
        assistantId: String,
        clientToken: String? = CreateAIGuardrailVersionRequest.idempotencyToken(),
        modifiedTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAIGuardrailVersionResponse {
        let input = CreateAIGuardrailVersionRequest(
            aiGuardrailId: aiGuardrailId, 
            assistantId: assistantId, 
            clientToken: clientToken, 
            modifiedTime: modifiedTime
        )
        return try await self.createAIGuardrailVersion(input, logger: logger)
    }

    /// Creates an Amazon Q in Connect AI Prompt.
    @Sendable
    @inlinable
    public func createAIPrompt(_ input: CreateAIPromptRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAIPromptResponse {
        try await self.client.execute(
            operation: "CreateAIPrompt", 
            path: "/assistants/{assistantId}/aiprompts", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Q in Connect AI Prompt.
    ///
    /// Parameters:
    ///   - apiFormat: The API Format of the AI Prompt. Recommended values: MESSAGES | TEXT_COMPLETIONS   The values ANTHROPIC_CLAUDE_MESSAGES | ANTHROPIC_CLAUDE_TEXT_COMPLETIONS will be deprecated.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs..
    ///   - description: The description of the AI Prompt.
    ///   - modelId: The identifier of the model used for this AI Prompt.
    ///   - name: The name of the AI Prompt.
    ///   - tags: The tags used to organize, track, or control access for this resource.
    ///   - templateConfiguration: The configuration of the prompt template for this AI Prompt.
    ///   - templateType: The type of the prompt template for this AI Prompt.
    ///   - type: The type of this AI Prompt.
    ///   - visibilityStatus: The visibility status of the AI Prompt.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAIPrompt(
        apiFormat: AIPromptAPIFormat,
        assistantId: String,
        clientToken: String? = CreateAIPromptRequest.idempotencyToken(),
        description: String? = nil,
        modelId: String,
        name: String,
        tags: [String: String]? = nil,
        templateConfiguration: AIPromptTemplateConfiguration,
        templateType: AIPromptTemplateType,
        type: AIPromptType,
        visibilityStatus: VisibilityStatus,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAIPromptResponse {
        let input = CreateAIPromptRequest(
            apiFormat: apiFormat, 
            assistantId: assistantId, 
            clientToken: clientToken, 
            description: description, 
            modelId: modelId, 
            name: name, 
            tags: tags, 
            templateConfiguration: templateConfiguration, 
            templateType: templateType, 
            type: type, 
            visibilityStatus: visibilityStatus
        )
        return try await self.createAIPrompt(input, logger: logger)
    }

    /// Creates an Amazon Q in Connect AI Prompt version.
    @Sendable
    @inlinable
    public func createAIPromptVersion(_ input: CreateAIPromptVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAIPromptVersionResponse {
        try await self.client.execute(
            operation: "CreateAIPromptVersion", 
            path: "/assistants/{assistantId}/aiprompts/{aiPromptId}/versions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Q in Connect AI Prompt version.
    ///
    /// Parameters:
    ///   - aiPromptId: The identifier of the Amazon Q in Connect AI prompt.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs..
    ///   - modifiedTime: The time the AI Prompt was last modified.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAIPromptVersion(
        aiPromptId: String,
        assistantId: String,
        clientToken: String? = CreateAIPromptVersionRequest.idempotencyToken(),
        modifiedTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAIPromptVersionResponse {
        let input = CreateAIPromptVersionRequest(
            aiPromptId: aiPromptId, 
            assistantId: assistantId, 
            clientToken: clientToken, 
            modifiedTime: modifiedTime
        )
        return try await self.createAIPromptVersion(input, logger: logger)
    }

    /// Creates an Amazon Q in Connect assistant.
    @Sendable
    @inlinable
    public func createAssistant(_ input: CreateAssistantRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAssistantResponse {
        try await self.client.execute(
            operation: "CreateAssistant", 
            path: "/assistants", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Q in Connect assistant.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - description: The description of the assistant.
    ///   - name: The name of the assistant.
    ///   - serverSideEncryptionConfiguration: The configuration information for the customer managed key used for encryption.  The customer managed key must have a policy that allows kms:CreateGrant,  kms:DescribeKey, kms:Decrypt, and kms:GenerateDataKey* permissions to the IAM identity using the key to invoke Amazon Q in Connect. To use Amazon Q in Connect with chat, the key policy must also allow kms:Decrypt, kms:GenerateDataKey*, and kms:DescribeKey permissions to the connect.amazonaws.com service principal.  For more information about setting up a customer managed key for Amazon Q in Connect, see Enable Amazon Q in Connect for your instance.
    ///   - tags: The tags used to organize, track, or control access for this resource.
    ///   - type: The type of assistant.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAssistant(
        clientToken: String? = CreateAssistantRequest.idempotencyToken(),
        description: String? = nil,
        name: String,
        serverSideEncryptionConfiguration: ServerSideEncryptionConfiguration? = nil,
        tags: [String: String]? = nil,
        type: AssistantType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAssistantResponse {
        let input = CreateAssistantRequest(
            clientToken: clientToken, 
            description: description, 
            name: name, 
            serverSideEncryptionConfiguration: serverSideEncryptionConfiguration, 
            tags: tags, 
            type: type
        )
        return try await self.createAssistant(input, logger: logger)
    }

    /// Creates an association between an Amazon Q in Connect assistant and another resource. Currently, the only supported association is with a knowledge base. An assistant can have only a single association.
    @Sendable
    @inlinable
    public func createAssistantAssociation(_ input: CreateAssistantAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAssistantAssociationResponse {
        try await self.client.execute(
            operation: "CreateAssistantAssociation", 
            path: "/assistants/{assistantId}/associations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an association between an Amazon Q in Connect assistant and another resource. Currently, the only supported association is with a knowledge base. An assistant can have only a single association.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - association: The identifier of the associated resource.
    ///   - associationType: The type of association.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - tags: The tags used to organize, track, or control access for this resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAssistantAssociation(
        assistantId: String,
        association: AssistantAssociationInputData,
        associationType: AssociationType,
        clientToken: String? = CreateAssistantAssociationRequest.idempotencyToken(),
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAssistantAssociationResponse {
        let input = CreateAssistantAssociationRequest(
            assistantId: assistantId, 
            association: association, 
            associationType: associationType, 
            clientToken: clientToken, 
            tags: tags
        )
        return try await self.createAssistantAssociation(input, logger: logger)
    }

    /// Creates Amazon Q in Connect content. Before to calling this API, use StartContentUpload to upload an asset.
    @Sendable
    @inlinable
    public func createContent(_ input: CreateContentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateContentResponse {
        try await self.client.execute(
            operation: "CreateContent", 
            path: "/knowledgeBases/{knowledgeBaseId}/contents", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates Amazon Q in Connect content. Before to calling this API, use StartContentUpload to upload an asset.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - knowledgeBaseId: The identifier of the knowledge base. This should not be a QUICK_RESPONSES type knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - metadata: A key/value map to store attributes without affecting tagging or recommendations. For example, when synchronizing data between an external system and Amazon Q in Connect, you can store an external version identifier as metadata to utilize for determining drift.
    ///   - name: The name of the content. Each piece of content in a knowledge base must have a unique name. You can retrieve a piece of content using only its knowledge base and its name with the SearchContent API.
    ///   - overrideLinkOutUri: The URI you want to use for the article. If the knowledge base has a templateUri, setting this argument overrides it for this piece of content.
    ///   - tags: The tags used to organize, track, or control access for this resource.
    ///   - title: The title of the content. If not set, the title is equal to the name.
    ///   - uploadId: A pointer to the uploaded asset. This value is returned by StartContentUpload.
    ///   - logger: Logger use during operation
    @inlinable
    public func createContent(
        clientToken: String? = CreateContentRequest.idempotencyToken(),
        knowledgeBaseId: String,
        metadata: [String: String]? = nil,
        name: String,
        overrideLinkOutUri: String? = nil,
        tags: [String: String]? = nil,
        title: String? = nil,
        uploadId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateContentResponse {
        let input = CreateContentRequest(
            clientToken: clientToken, 
            knowledgeBaseId: knowledgeBaseId, 
            metadata: metadata, 
            name: name, 
            overrideLinkOutUri: overrideLinkOutUri, 
            tags: tags, 
            title: title, 
            uploadId: uploadId
        )
        return try await self.createContent(input, logger: logger)
    }

    /// Creates an association between a content resource in a knowledge base and step-by-step guides. Step-by-step guides offer instructions to agents for resolving common customer issues. You create a content association to integrate Amazon Q in Connect and step-by-step guides.  After you integrate Amazon Q and step-by-step guides, when Amazon Q provides a recommendation to an agent based on the intent that it's detected, it also provides them with the option to start the step-by-step guide that you have associated with the content. Note the following limitations:   You can create only one content association for each content resource in a knowledge base.   You can associate a step-by-step guide with multiple content resources.   For more information, see Integrate Amazon Q in Connect with step-by-step guides in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func createContentAssociation(_ input: CreateContentAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateContentAssociationResponse {
        try await self.client.execute(
            operation: "CreateContentAssociation", 
            path: "/knowledgeBases/{knowledgeBaseId}/contents/{contentId}/associations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an association between a content resource in a knowledge base and step-by-step guides. Step-by-step guides offer instructions to agents for resolving common customer issues. You create a content association to integrate Amazon Q in Connect and step-by-step guides.  After you integrate Amazon Q and step-by-step guides, when Amazon Q provides a recommendation to an agent based on the intent that it's detected, it also provides them with the option to start the step-by-step guide that you have associated with the content. Note the following limitations:   You can create only one content association for each content resource in a knowledge base.   You can associate a step-by-step guide with multiple content resources.   For more information, see Integrate Amazon Q in Connect with step-by-step guides in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - association: The identifier of the associated resource.
    ///   - associationType: The type of association.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - contentId: The identifier of the content.
    ///   - knowledgeBaseId: The identifier of the knowledge base.
    ///   - tags: The tags used to organize, track, or control access for this resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createContentAssociation(
        association: ContentAssociationContents,
        associationType: ContentAssociationType,
        clientToken: String? = CreateContentAssociationRequest.idempotencyToken(),
        contentId: String,
        knowledgeBaseId: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateContentAssociationResponse {
        let input = CreateContentAssociationRequest(
            association: association, 
            associationType: associationType, 
            clientToken: clientToken, 
            contentId: contentId, 
            knowledgeBaseId: knowledgeBaseId, 
            tags: tags
        )
        return try await self.createContentAssociation(input, logger: logger)
    }

    /// Creates a knowledge base.  When using this API, you cannot reuse Amazon AppIntegrations DataIntegrations with external knowledge bases such as Salesforce and ServiceNow. If you do, you'll get an InvalidRequestException error.  For example, you're programmatically managing your external knowledge base, and you want to add or remove one of the fields that is being ingested from Salesforce. Do the following:   Call DeleteKnowledgeBase.   Call DeleteDataIntegration.   Call CreateDataIntegration to recreate the DataIntegration or a create different one.   Call CreateKnowledgeBase.
    @Sendable
    @inlinable
    public func createKnowledgeBase(_ input: CreateKnowledgeBaseRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateKnowledgeBaseResponse {
        try await self.client.execute(
            operation: "CreateKnowledgeBase", 
            path: "/knowledgeBases", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a knowledge base.  When using this API, you cannot reuse Amazon AppIntegrations DataIntegrations with external knowledge bases such as Salesforce and ServiceNow. If you do, you'll get an InvalidRequestException error.  For example, you're programmatically managing your external knowledge base, and you want to add or remove one of the fields that is being ingested from Salesforce. Do the following:   Call DeleteKnowledgeBase.   Call DeleteDataIntegration.   Call CreateDataIntegration to recreate the DataIntegration or a create different one.   Call CreateKnowledgeBase.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - description: The description.
    ///   - knowledgeBaseType: The type of knowledge base. Only CUSTOM knowledge bases allow you to upload your own content. EXTERNAL knowledge bases support integrations with third-party systems whose content is synchronized automatically.
    ///   - name: The name of the knowledge base.
    ///   - renderingConfiguration: Information about how to render the content.
    ///   - serverSideEncryptionConfiguration: The configuration information for the customer managed key used for encryption.  This KMS key must have a policy that allows kms:CreateGrant, kms:DescribeKey, kms:Decrypt, and kms:GenerateDataKey* permissions to the IAM identity using the key to invoke Amazon Q in Connect. For more information about setting up a customer managed key for Amazon Q in Connect, see Enable Amazon Q in Connect for your instance.
    ///   - sourceConfiguration: The source of the knowledge base content. Only set this argument for EXTERNAL or Managed knowledge bases.
    ///   - tags: The tags used to organize, track, or control access for this resource.
    ///   - vectorIngestionConfiguration: Contains details about how to ingest the documents in a data source.
    ///   - logger: Logger use during operation
    @inlinable
    public func createKnowledgeBase(
        clientToken: String? = CreateKnowledgeBaseRequest.idempotencyToken(),
        description: String? = nil,
        knowledgeBaseType: KnowledgeBaseType,
        name: String,
        renderingConfiguration: RenderingConfiguration? = nil,
        serverSideEncryptionConfiguration: ServerSideEncryptionConfiguration? = nil,
        sourceConfiguration: SourceConfiguration? = nil,
        tags: [String: String]? = nil,
        vectorIngestionConfiguration: VectorIngestionConfiguration? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateKnowledgeBaseResponse {
        let input = CreateKnowledgeBaseRequest(
            clientToken: clientToken, 
            description: description, 
            knowledgeBaseType: knowledgeBaseType, 
            name: name, 
            renderingConfiguration: renderingConfiguration, 
            serverSideEncryptionConfiguration: serverSideEncryptionConfiguration, 
            sourceConfiguration: sourceConfiguration, 
            tags: tags, 
            vectorIngestionConfiguration: vectorIngestionConfiguration
        )
        return try await self.createKnowledgeBase(input, logger: logger)
    }

    /// Creates an Amazon Q in Connect message template. The name of the message template has to be unique for each knowledge base. The channel subtype of the message template is immutable and cannot be modified after creation. After the message template is created, you can use the $LATEST qualifier to reference the created message template.
    @Sendable
    @inlinable
    public func createMessageTemplate(_ input: CreateMessageTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateMessageTemplateResponse {
        try await self.client.execute(
            operation: "CreateMessageTemplate", 
            path: "/knowledgeBases/{knowledgeBaseId}/messageTemplates", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Q in Connect message template. The name of the message template has to be unique for each knowledge base. The channel subtype of the message template is immutable and cannot be modified after creation. After the message template is created, you can use the $LATEST qualifier to reference the created message template.
    ///
    /// Parameters:
    ///   - channelSubtype: The channel subtype this message template applies to.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - content: The content of the message template.
    ///   - defaultAttributes: An object that specifies the default values to use for variables in the message template. This object contains different categories of key-value pairs. Each key defines a variable or placeholder in the message template. The corresponding value defines the default value for that variable.
    ///   - description: The description of the message template.
    ///   - groupingConfiguration: 
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - language: The language code value for the language in which the quick response is written. The supported language codes include de_DE, en_US, es_ES, fr_FR, id_ID, it_IT, ja_JP, ko_KR, pt_BR, zh_CN, zh_TW
    ///   - name: The name of the message template.
    ///   - tags: The tags used to organize, track, or control access for this resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMessageTemplate(
        channelSubtype: ChannelSubtype,
        clientToken: String? = CreateMessageTemplateRequest.idempotencyToken(),
        content: MessageTemplateContentProvider,
        defaultAttributes: MessageTemplateAttributes? = nil,
        description: String? = nil,
        groupingConfiguration: GroupingConfiguration? = nil,
        knowledgeBaseId: String,
        language: String? = nil,
        name: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateMessageTemplateResponse {
        let input = CreateMessageTemplateRequest(
            channelSubtype: channelSubtype, 
            clientToken: clientToken, 
            content: content, 
            defaultAttributes: defaultAttributes, 
            description: description, 
            groupingConfiguration: groupingConfiguration, 
            knowledgeBaseId: knowledgeBaseId, 
            language: language, 
            name: name, 
            tags: tags
        )
        return try await self.createMessageTemplate(input, logger: logger)
    }

    /// Uploads an attachment file to the specified Amazon Q in Connect message template. The name of the message template attachment has to be unique for each message template referenced by the $LATEST qualifier. The body of the attachment file should be encoded using base64 encoding. After the file is uploaded, you can use the pre-signed Amazon S3 URL returned in response to download the uploaded file.
    @Sendable
    @inlinable
    public func createMessageTemplateAttachment(_ input: CreateMessageTemplateAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateMessageTemplateAttachmentResponse {
        try await self.client.execute(
            operation: "CreateMessageTemplateAttachment", 
            path: "/knowledgeBases/{knowledgeBaseId}/messageTemplates/{messageTemplateId}/attachments", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Uploads an attachment file to the specified Amazon Q in Connect message template. The name of the message template attachment has to be unique for each message template referenced by the $LATEST qualifier. The body of the attachment file should be encoded using base64 encoding. After the file is uploaded, you can use the pre-signed Amazon S3 URL returned in response to download the uploaded file.
    ///
    /// Parameters:
    ///   - body: The body of the attachment file being uploaded. It should be encoded using base64 encoding.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - contentDisposition: The presentation information for the attachment file.
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - messageTemplateId: The identifier of the message template. Can be either the ID or the ARN. It cannot contain any qualifier.
    ///   - name: The name of the attachment file being uploaded. The name should include the file extension.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMessageTemplateAttachment(
        body: String,
        clientToken: String? = nil,
        contentDisposition: ContentDisposition,
        knowledgeBaseId: String,
        messageTemplateId: String,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateMessageTemplateAttachmentResponse {
        let input = CreateMessageTemplateAttachmentRequest(
            body: body, 
            clientToken: clientToken, 
            contentDisposition: contentDisposition, 
            knowledgeBaseId: knowledgeBaseId, 
            messageTemplateId: messageTemplateId, 
            name: name
        )
        return try await self.createMessageTemplateAttachment(input, logger: logger)
    }

    /// Creates a new Amazon Q in Connect message template version from the current content and configuration of a message template. Versions are immutable and monotonically increasing. Once a version is created, you can reference a specific version of the message template by passing in &lt;message-template-id&gt;:&lt;versionNumber&gt; as the message template identifier. An error is displayed if the supplied messageTemplateContentSha256 is different from the messageTemplateContentSha256 of the message template with $LATEST qualifier. If multiple CreateMessageTemplateVersion requests are made while the message template remains the same, only the first invocation creates a new version and the succeeding requests will return the same response as the first invocation.
    @Sendable
    @inlinable
    public func createMessageTemplateVersion(_ input: CreateMessageTemplateVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateMessageTemplateVersionResponse {
        try await self.client.execute(
            operation: "CreateMessageTemplateVersion", 
            path: "/knowledgeBases/{knowledgeBaseId}/messageTemplates/{messageTemplateId}/versions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new Amazon Q in Connect message template version from the current content and configuration of a message template. Versions are immutable and monotonically increasing. Once a version is created, you can reference a specific version of the message template by passing in &lt;message-template-id&gt;:&lt;versionNumber&gt; as the message template identifier. An error is displayed if the supplied messageTemplateContentSha256 is different from the messageTemplateContentSha256 of the message template with $LATEST qualifier. If multiple CreateMessageTemplateVersion requests are made while the message template remains the same, only the first invocation creates a new version and the succeeding requests will return the same response as the first invocation.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - messageTemplateContentSha256: The checksum value of the message template content that is referenced by the $LATEST qualifier. It can be returned in MessageTemplateData or ExtendedMessageTemplateData. It’s calculated by content, language, defaultAttributes and Attachments of the message template. If not supplied, the message template version will be created based on the message template content that is referenced by the $LATEST qualifier by default.
    ///   - messageTemplateId: The identifier of the message template. Can be either the ID or the ARN. It cannot contain any qualifier.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMessageTemplateVersion(
        knowledgeBaseId: String,
        messageTemplateContentSha256: String? = nil,
        messageTemplateId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateMessageTemplateVersionResponse {
        let input = CreateMessageTemplateVersionRequest(
            knowledgeBaseId: knowledgeBaseId, 
            messageTemplateContentSha256: messageTemplateContentSha256, 
            messageTemplateId: messageTemplateId
        )
        return try await self.createMessageTemplateVersion(input, logger: logger)
    }

    /// Creates an Amazon Q in Connect quick response.
    @Sendable
    @inlinable
    public func createQuickResponse(_ input: CreateQuickResponseRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateQuickResponseResponse {
        try await self.client.execute(
            operation: "CreateQuickResponse", 
            path: "/knowledgeBases/{knowledgeBaseId}/quickResponses", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Q in Connect quick response.
    ///
    /// Parameters:
    ///   - channels: The Amazon Connect channels this quick response applies to.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - content: The content of the quick response.
    ///   - contentType: The media type of the quick response content.   Use application/x.quickresponse;format=plain for a quick response written in plain text.   Use application/x.quickresponse;format=markdown for a quick response written in richtext.
    ///   - description: The description of the quick response.
    ///   - groupingConfiguration: The configuration information of the user groups that the quick response is accessible to.
    ///   - isActive: Whether the quick response is active.
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - language: The language code value for the language in which the quick response is written. The supported language codes include de_DE, en_US, es_ES, fr_FR, id_ID, it_IT, ja_JP, ko_KR, pt_BR, zh_CN, zh_TW
    ///   - name: The name of the quick response.
    ///   - shortcutKey: The shortcut key of the quick response. The value should be unique across the knowledge base.
    ///   - tags: The tags used to organize, track, or control access for this resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createQuickResponse(
        channels: [String]? = nil,
        clientToken: String? = CreateQuickResponseRequest.idempotencyToken(),
        content: QuickResponseDataProvider,
        contentType: String? = nil,
        description: String? = nil,
        groupingConfiguration: GroupingConfiguration? = nil,
        isActive: Bool? = nil,
        knowledgeBaseId: String,
        language: String? = nil,
        name: String,
        shortcutKey: String? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateQuickResponseResponse {
        let input = CreateQuickResponseRequest(
            channels: channels, 
            clientToken: clientToken, 
            content: content, 
            contentType: contentType, 
            description: description, 
            groupingConfiguration: groupingConfiguration, 
            isActive: isActive, 
            knowledgeBaseId: knowledgeBaseId, 
            language: language, 
            name: name, 
            shortcutKey: shortcutKey, 
            tags: tags
        )
        return try await self.createQuickResponse(input, logger: logger)
    }

    /// Creates a session. A session is a contextual container used for generating recommendations. Amazon Connect creates a new Amazon Q in Connect session for each contact on which Amazon Q in Connect is enabled.
    @Sendable
    @inlinable
    public func createSession(_ input: CreateSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSessionResponse {
        try await self.client.execute(
            operation: "CreateSession", 
            path: "/assistants/{assistantId}/sessions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a session. A session is a contextual container used for generating recommendations. Amazon Connect creates a new Amazon Q in Connect session for each contact on which Amazon Q in Connect is enabled.
    ///
    /// Parameters:
    ///   - aiAgentConfiguration: The configuration of the AI Agents (mapped by AI Agent Type to AI Agent version) that should be used by Amazon Q in Connect for this Session.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - description: The description.
    ///   - name: The name of the session.
    ///   - tagFilter: An object that can be used to specify Tag conditions.
    ///   - tags: The tags used to organize, track, or control access for this resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSession(
        aiAgentConfiguration: [AIAgentType: AIAgentConfigurationData]? = nil,
        assistantId: String,
        clientToken: String? = CreateSessionRequest.idempotencyToken(),
        description: String? = nil,
        name: String,
        tagFilter: TagFilter? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSessionResponse {
        let input = CreateSessionRequest(
            aiAgentConfiguration: aiAgentConfiguration, 
            assistantId: assistantId, 
            clientToken: clientToken, 
            description: description, 
            name: name, 
            tagFilter: tagFilter, 
            tags: tags
        )
        return try await self.createSession(input, logger: logger)
    }

    /// Deactivates a specific version of the Amazon Q in Connect message template . After the version is deactivated, you can no longer use the $ACTIVE_VERSION qualifier to reference the version in active status.
    @Sendable
    @inlinable
    public func deactivateMessageTemplate(_ input: DeactivateMessageTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeactivateMessageTemplateResponse {
        try await self.client.execute(
            operation: "DeactivateMessageTemplate", 
            path: "/knowledgeBases/{knowledgeBaseId}/messageTemplates/{messageTemplateId}/deactivate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deactivates a specific version of the Amazon Q in Connect message template . After the version is deactivated, you can no longer use the $ACTIVE_VERSION qualifier to reference the version in active status.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - messageTemplateId: The identifier of the message template. Can be either the ID or the ARN. It cannot contain any qualifier.
    ///   - versionNumber: The version number of the message template version to deactivate.
    ///   - logger: Logger use during operation
    @inlinable
    public func deactivateMessageTemplate(
        knowledgeBaseId: String,
        messageTemplateId: String,
        versionNumber: Int64,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeactivateMessageTemplateResponse {
        let input = DeactivateMessageTemplateRequest(
            knowledgeBaseId: knowledgeBaseId, 
            messageTemplateId: messageTemplateId, 
            versionNumber: versionNumber
        )
        return try await self.deactivateMessageTemplate(input, logger: logger)
    }

    /// Deletes an Amazon Q in Connect AI Agent.
    @Sendable
    @inlinable
    public func deleteAIAgent(_ input: DeleteAIAgentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAIAgentResponse {
        try await self.client.execute(
            operation: "DeleteAIAgent", 
            path: "/assistants/{assistantId}/aiagents/{aiAgentId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon Q in Connect AI Agent.
    ///
    /// Parameters:
    ///   - aiAgentId: The identifier of the Amazon Q in Connect AI Agent. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAIAgent(
        aiAgentId: String,
        assistantId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAIAgentResponse {
        let input = DeleteAIAgentRequest(
            aiAgentId: aiAgentId, 
            assistantId: assistantId
        )
        return try await self.deleteAIAgent(input, logger: logger)
    }

    /// Deletes an Amazon Q in Connect AI Agent Version.
    @Sendable
    @inlinable
    public func deleteAIAgentVersion(_ input: DeleteAIAgentVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAIAgentVersionResponse {
        try await self.client.execute(
            operation: "DeleteAIAgentVersion", 
            path: "/assistants/{assistantId}/aiagents/{aiAgentId}/versions/{versionNumber}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon Q in Connect AI Agent Version.
    ///
    /// Parameters:
    ///   - aiAgentId: The identifier of the Amazon Q in Connect AI Agent. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - versionNumber: The version number of the AI Agent version.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAIAgentVersion(
        aiAgentId: String,
        assistantId: String,
        versionNumber: Int64,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAIAgentVersionResponse {
        let input = DeleteAIAgentVersionRequest(
            aiAgentId: aiAgentId, 
            assistantId: assistantId, 
            versionNumber: versionNumber
        )
        return try await self.deleteAIAgentVersion(input, logger: logger)
    }

    /// Deletes an Amazon Q in Connect AI Guardrail.
    @Sendable
    @inlinable
    public func deleteAIGuardrail(_ input: DeleteAIGuardrailRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAIGuardrailResponse {
        try await self.client.execute(
            operation: "DeleteAIGuardrail", 
            path: "/assistants/{assistantId}/aiguardrails/{aiGuardrailId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon Q in Connect AI Guardrail.
    ///
    /// Parameters:
    ///   - aiGuardrailId: The identifier of the Amazon Q in Connect AI Guardrail. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAIGuardrail(
        aiGuardrailId: String,
        assistantId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAIGuardrailResponse {
        let input = DeleteAIGuardrailRequest(
            aiGuardrailId: aiGuardrailId, 
            assistantId: assistantId
        )
        return try await self.deleteAIGuardrail(input, logger: logger)
    }

    /// Delete and Amazon Q in Connect AI Guardrail version.
    @Sendable
    @inlinable
    public func deleteAIGuardrailVersion(_ input: DeleteAIGuardrailVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAIGuardrailVersionResponse {
        try await self.client.execute(
            operation: "DeleteAIGuardrailVersion", 
            path: "/assistants/{assistantId}/aiguardrails/{aiGuardrailId}/versions/{versionNumber}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Delete and Amazon Q in Connect AI Guardrail version.
    ///
    /// Parameters:
    ///   - aiGuardrailId: The identifier of the Amazon Q in Connect AI Guardrail.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - versionNumber: The version number of the AI Guardrail version to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAIGuardrailVersion(
        aiGuardrailId: String,
        assistantId: String,
        versionNumber: Int64,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAIGuardrailVersionResponse {
        let input = DeleteAIGuardrailVersionRequest(
            aiGuardrailId: aiGuardrailId, 
            assistantId: assistantId, 
            versionNumber: versionNumber
        )
        return try await self.deleteAIGuardrailVersion(input, logger: logger)
    }

    /// Deletes an Amazon Q in Connect AI Prompt.
    @Sendable
    @inlinable
    public func deleteAIPrompt(_ input: DeleteAIPromptRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAIPromptResponse {
        try await self.client.execute(
            operation: "DeleteAIPrompt", 
            path: "/assistants/{assistantId}/aiprompts/{aiPromptId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon Q in Connect AI Prompt.
    ///
    /// Parameters:
    ///   - aiPromptId: The identifier of the Amazon Q in Connect AI prompt. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAIPrompt(
        aiPromptId: String,
        assistantId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAIPromptResponse {
        let input = DeleteAIPromptRequest(
            aiPromptId: aiPromptId, 
            assistantId: assistantId
        )
        return try await self.deleteAIPrompt(input, logger: logger)
    }

    /// Delete and Amazon Q in Connect AI Prompt version.
    @Sendable
    @inlinable
    public func deleteAIPromptVersion(_ input: DeleteAIPromptVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAIPromptVersionResponse {
        try await self.client.execute(
            operation: "DeleteAIPromptVersion", 
            path: "/assistants/{assistantId}/aiprompts/{aiPromptId}/versions/{versionNumber}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Delete and Amazon Q in Connect AI Prompt version.
    ///
    /// Parameters:
    ///   - aiPromptId: The identifier of the Amazon Q in Connect AI prompt.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - versionNumber: The version number of the AI Prompt version to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAIPromptVersion(
        aiPromptId: String,
        assistantId: String,
        versionNumber: Int64,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAIPromptVersionResponse {
        let input = DeleteAIPromptVersionRequest(
            aiPromptId: aiPromptId, 
            assistantId: assistantId, 
            versionNumber: versionNumber
        )
        return try await self.deleteAIPromptVersion(input, logger: logger)
    }

    /// Deletes an assistant.
    @Sendable
    @inlinable
    public func deleteAssistant(_ input: DeleteAssistantRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAssistantResponse {
        try await self.client.execute(
            operation: "DeleteAssistant", 
            path: "/assistants/{assistantId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an assistant.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAssistant(
        assistantId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAssistantResponse {
        let input = DeleteAssistantRequest(
            assistantId: assistantId
        )
        return try await self.deleteAssistant(input, logger: logger)
    }

    /// Deletes an assistant association.
    @Sendable
    @inlinable
    public func deleteAssistantAssociation(_ input: DeleteAssistantAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAssistantAssociationResponse {
        try await self.client.execute(
            operation: "DeleteAssistantAssociation", 
            path: "/assistants/{assistantId}/associations/{assistantAssociationId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an assistant association.
    ///
    /// Parameters:
    ///   - assistantAssociationId: The identifier of the assistant association. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAssistantAssociation(
        assistantAssociationId: String,
        assistantId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAssistantAssociationResponse {
        let input = DeleteAssistantAssociationRequest(
            assistantAssociationId: assistantAssociationId, 
            assistantId: assistantId
        )
        return try await self.deleteAssistantAssociation(input, logger: logger)
    }

    /// Deletes the content.
    @Sendable
    @inlinable
    public func deleteContent(_ input: DeleteContentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteContentResponse {
        try await self.client.execute(
            operation: "DeleteContent", 
            path: "/knowledgeBases/{knowledgeBaseId}/contents/{contentId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the content.
    ///
    /// Parameters:
    ///   - contentId: The identifier of the content. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteContent(
        contentId: String,
        knowledgeBaseId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteContentResponse {
        let input = DeleteContentRequest(
            contentId: contentId, 
            knowledgeBaseId: knowledgeBaseId
        )
        return try await self.deleteContent(input, logger: logger)
    }

    /// Deletes the content association.  For more information about content associations--what they are and when they are used--see Integrate Amazon Q in Connect with step-by-step guides in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func deleteContentAssociation(_ input: DeleteContentAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteContentAssociationResponse {
        try await self.client.execute(
            operation: "DeleteContentAssociation", 
            path: "/knowledgeBases/{knowledgeBaseId}/contents/{contentId}/associations/{contentAssociationId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the content association.  For more information about content associations--what they are and when they are used--see Integrate Amazon Q in Connect with step-by-step guides in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - contentAssociationId: The identifier of the content association. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - contentId: The identifier of the content.
    ///   - knowledgeBaseId: The identifier of the knowledge base.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteContentAssociation(
        contentAssociationId: String,
        contentId: String,
        knowledgeBaseId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteContentAssociationResponse {
        let input = DeleteContentAssociationRequest(
            contentAssociationId: contentAssociationId, 
            contentId: contentId, 
            knowledgeBaseId: knowledgeBaseId
        )
        return try await self.deleteContentAssociation(input, logger: logger)
    }

    /// Deletes the quick response import job.
    @Sendable
    @inlinable
    public func deleteImportJob(_ input: DeleteImportJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteImportJobResponse {
        try await self.client.execute(
            operation: "DeleteImportJob", 
            path: "/knowledgeBases/{knowledgeBaseId}/importJobs/{importJobId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the quick response import job.
    ///
    /// Parameters:
    ///   - importJobId: The identifier of the import job to be deleted.
    ///   - knowledgeBaseId: The identifier of the knowledge base.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteImportJob(
        importJobId: String,
        knowledgeBaseId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteImportJobResponse {
        let input = DeleteImportJobRequest(
            importJobId: importJobId, 
            knowledgeBaseId: knowledgeBaseId
        )
        return try await self.deleteImportJob(input, logger: logger)
    }

    /// Deletes the knowledge base.  When you use this API to delete an external knowledge base such as Salesforce or ServiceNow, you must also delete the Amazon AppIntegrations DataIntegration. This is because you can't reuse the DataIntegration after it's been associated with an external knowledge base. However, you can delete and recreate it. See DeleteDataIntegration and CreateDataIntegration in the Amazon AppIntegrations API Reference.
    @Sendable
    @inlinable
    public func deleteKnowledgeBase(_ input: DeleteKnowledgeBaseRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteKnowledgeBaseResponse {
        try await self.client.execute(
            operation: "DeleteKnowledgeBase", 
            path: "/knowledgeBases/{knowledgeBaseId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the knowledge base.  When you use this API to delete an external knowledge base such as Salesforce or ServiceNow, you must also delete the Amazon AppIntegrations DataIntegration. This is because you can't reuse the DataIntegration after it's been associated with an external knowledge base. However, you can delete and recreate it. See DeleteDataIntegration and CreateDataIntegration in the Amazon AppIntegrations API Reference.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The knowledge base to delete content from. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteKnowledgeBase(
        knowledgeBaseId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteKnowledgeBaseResponse {
        let input = DeleteKnowledgeBaseRequest(
            knowledgeBaseId: knowledgeBaseId
        )
        return try await self.deleteKnowledgeBase(input, logger: logger)
    }

    /// Deletes an Amazon Q in Connect message template entirely or a specific version of the message template if version is supplied in the request. You can provide the message template identifier as &lt;message-template-id&gt;:&lt;versionNumber&gt; to delete a specific version of the message template. If it is not supplied, the message template and all available versions will be deleted.
    @Sendable
    @inlinable
    public func deleteMessageTemplate(_ input: DeleteMessageTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteMessageTemplateResponse {
        try await self.client.execute(
            operation: "DeleteMessageTemplate", 
            path: "/knowledgeBases/{knowledgeBaseId}/messageTemplates/{messageTemplateId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon Q in Connect message template entirely or a specific version of the message template if version is supplied in the request. You can provide the message template identifier as &lt;message-template-id&gt;:&lt;versionNumber&gt; to delete a specific version of the message template. If it is not supplied, the message template and all available versions will be deleted.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - messageTemplateId: The identifier of the message template. Can be either the ID or the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteMessageTemplate(
        knowledgeBaseId: String,
        messageTemplateId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteMessageTemplateResponse {
        let input = DeleteMessageTemplateRequest(
            knowledgeBaseId: knowledgeBaseId, 
            messageTemplateId: messageTemplateId
        )
        return try await self.deleteMessageTemplate(input, logger: logger)
    }

    /// Deletes the attachment file from the Amazon Q in Connect message template that is referenced by $LATEST qualifier. Attachments on available message template versions will remain unchanged.
    @Sendable
    @inlinable
    public func deleteMessageTemplateAttachment(_ input: DeleteMessageTemplateAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteMessageTemplateAttachmentResponse {
        try await self.client.execute(
            operation: "DeleteMessageTemplateAttachment", 
            path: "/knowledgeBases/{knowledgeBaseId}/messageTemplates/{messageTemplateId}/attachments/{attachmentId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the attachment file from the Amazon Q in Connect message template that is referenced by $LATEST qualifier. Attachments on available message template versions will remain unchanged.
    ///
    /// Parameters:
    ///   - attachmentId: The identifier of the attachment file.
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - messageTemplateId: The identifier of the message template. Can be either the ID or the ARN. It cannot contain any qualifier.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteMessageTemplateAttachment(
        attachmentId: String,
        knowledgeBaseId: String,
        messageTemplateId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteMessageTemplateAttachmentResponse {
        let input = DeleteMessageTemplateAttachmentRequest(
            attachmentId: attachmentId, 
            knowledgeBaseId: knowledgeBaseId, 
            messageTemplateId: messageTemplateId
        )
        return try await self.deleteMessageTemplateAttachment(input, logger: logger)
    }

    /// Deletes a quick response.
    @Sendable
    @inlinable
    public func deleteQuickResponse(_ input: DeleteQuickResponseRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteQuickResponseResponse {
        try await self.client.execute(
            operation: "DeleteQuickResponse", 
            path: "/knowledgeBases/{knowledgeBaseId}/quickResponses/{quickResponseId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a quick response.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The knowledge base from which the quick response is deleted. The identifier of the knowledge base.
    ///   - quickResponseId: The identifier of the quick response to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteQuickResponse(
        knowledgeBaseId: String,
        quickResponseId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteQuickResponseResponse {
        let input = DeleteQuickResponseRequest(
            knowledgeBaseId: knowledgeBaseId, 
            quickResponseId: quickResponseId
        )
        return try await self.deleteQuickResponse(input, logger: logger)
    }

    /// Gets an Amazon Q in Connect AI Agent.
    @Sendable
    @inlinable
    public func getAIAgent(_ input: GetAIAgentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAIAgentResponse {
        try await self.client.execute(
            operation: "GetAIAgent", 
            path: "/assistants/{assistantId}/aiagents/{aiAgentId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets an Amazon Q in Connect AI Agent.
    ///
    /// Parameters:
    ///   - aiAgentId: The identifier of the Amazon Q in Connect AI Agent (with or without a version qualifier). Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAIAgent(
        aiAgentId: String,
        assistantId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAIAgentResponse {
        let input = GetAIAgentRequest(
            aiAgentId: aiAgentId, 
            assistantId: assistantId
        )
        return try await self.getAIAgent(input, logger: logger)
    }

    /// Gets the Amazon Q in Connect AI Guardrail.
    @Sendable
    @inlinable
    public func getAIGuardrail(_ input: GetAIGuardrailRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAIGuardrailResponse {
        try await self.client.execute(
            operation: "GetAIGuardrail", 
            path: "/assistants/{assistantId}/aiguardrails/{aiGuardrailId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the Amazon Q in Connect AI Guardrail.
    ///
    /// Parameters:
    ///   - aiGuardrailId: The identifier of the Amazon Q in Connect AI Guardrail.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAIGuardrail(
        aiGuardrailId: String,
        assistantId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAIGuardrailResponse {
        let input = GetAIGuardrailRequest(
            aiGuardrailId: aiGuardrailId, 
            assistantId: assistantId
        )
        return try await self.getAIGuardrail(input, logger: logger)
    }

    /// Gets and Amazon Q in Connect AI Prompt.
    @Sendable
    @inlinable
    public func getAIPrompt(_ input: GetAIPromptRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAIPromptResponse {
        try await self.client.execute(
            operation: "GetAIPrompt", 
            path: "/assistants/{assistantId}/aiprompts/{aiPromptId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets and Amazon Q in Connect AI Prompt.
    ///
    /// Parameters:
    ///   - aiPromptId: The identifier of the Amazon Q in Connect AI prompt.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAIPrompt(
        aiPromptId: String,
        assistantId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAIPromptResponse {
        let input = GetAIPromptRequest(
            aiPromptId: aiPromptId, 
            assistantId: assistantId
        )
        return try await self.getAIPrompt(input, logger: logger)
    }

    /// Retrieves information about an assistant.
    @Sendable
    @inlinable
    public func getAssistant(_ input: GetAssistantRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAssistantResponse {
        try await self.client.execute(
            operation: "GetAssistant", 
            path: "/assistants/{assistantId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about an assistant.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAssistant(
        assistantId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAssistantResponse {
        let input = GetAssistantRequest(
            assistantId: assistantId
        )
        return try await self.getAssistant(input, logger: logger)
    }

    /// Retrieves information about an assistant association.
    @Sendable
    @inlinable
    public func getAssistantAssociation(_ input: GetAssistantAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAssistantAssociationResponse {
        try await self.client.execute(
            operation: "GetAssistantAssociation", 
            path: "/assistants/{assistantId}/associations/{assistantAssociationId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about an assistant association.
    ///
    /// Parameters:
    ///   - assistantAssociationId: The identifier of the assistant association. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAssistantAssociation(
        assistantAssociationId: String,
        assistantId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAssistantAssociationResponse {
        let input = GetAssistantAssociationRequest(
            assistantAssociationId: assistantAssociationId, 
            assistantId: assistantId
        )
        return try await self.getAssistantAssociation(input, logger: logger)
    }

    /// Retrieves content, including a pre-signed URL to download the content.
    @Sendable
    @inlinable
    public func getContent(_ input: GetContentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetContentResponse {
        try await self.client.execute(
            operation: "GetContent", 
            path: "/knowledgeBases/{knowledgeBaseId}/contents/{contentId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves content, including a pre-signed URL to download the content.
    ///
    /// Parameters:
    ///   - contentId: The identifier of the content. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - knowledgeBaseId: The identifier of the knowledge base. This should not be a QUICK_RESPONSES type knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getContent(
        contentId: String,
        knowledgeBaseId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetContentResponse {
        let input = GetContentRequest(
            contentId: contentId, 
            knowledgeBaseId: knowledgeBaseId
        )
        return try await self.getContent(input, logger: logger)
    }

    /// Returns the content association. For more information about content associations--what they are and when they are used--see Integrate Amazon Q in Connect with step-by-step guides in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func getContentAssociation(_ input: GetContentAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetContentAssociationResponse {
        try await self.client.execute(
            operation: "GetContentAssociation", 
            path: "/knowledgeBases/{knowledgeBaseId}/contents/{contentId}/associations/{contentAssociationId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the content association. For more information about content associations--what they are and when they are used--see Integrate Amazon Q in Connect with step-by-step guides in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - contentAssociationId: The identifier of the content association. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - contentId: The identifier of the content.
    ///   - knowledgeBaseId: The identifier of the knowledge base.
    ///   - logger: Logger use during operation
    @inlinable
    public func getContentAssociation(
        contentAssociationId: String,
        contentId: String,
        knowledgeBaseId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetContentAssociationResponse {
        let input = GetContentAssociationRequest(
            contentAssociationId: contentAssociationId, 
            contentId: contentId, 
            knowledgeBaseId: knowledgeBaseId
        )
        return try await self.getContentAssociation(input, logger: logger)
    }

    /// Retrieves summary information about the content.
    @Sendable
    @inlinable
    public func getContentSummary(_ input: GetContentSummaryRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetContentSummaryResponse {
        try await self.client.execute(
            operation: "GetContentSummary", 
            path: "/knowledgeBases/{knowledgeBaseId}/contents/{contentId}/summary", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves summary information about the content.
    ///
    /// Parameters:
    ///   - contentId: The identifier of the content. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getContentSummary(
        contentId: String,
        knowledgeBaseId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetContentSummaryResponse {
        let input = GetContentSummaryRequest(
            contentId: contentId, 
            knowledgeBaseId: knowledgeBaseId
        )
        return try await self.getContentSummary(input, logger: logger)
    }

    /// Retrieves the started import job.
    @Sendable
    @inlinable
    public func getImportJob(_ input: GetImportJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetImportJobResponse {
        try await self.client.execute(
            operation: "GetImportJob", 
            path: "/knowledgeBases/{knowledgeBaseId}/importJobs/{importJobId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the started import job.
    ///
    /// Parameters:
    ///   - importJobId: The identifier of the import job to retrieve.
    ///   - knowledgeBaseId: The identifier of the knowledge base that the import job belongs to.
    ///   - logger: Logger use during operation
    @inlinable
    public func getImportJob(
        importJobId: String,
        knowledgeBaseId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetImportJobResponse {
        let input = GetImportJobRequest(
            importJobId: importJobId, 
            knowledgeBaseId: knowledgeBaseId
        )
        return try await self.getImportJob(input, logger: logger)
    }

    /// Retrieves information about the knowledge base.
    @Sendable
    @inlinable
    public func getKnowledgeBase(_ input: GetKnowledgeBaseRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetKnowledgeBaseResponse {
        try await self.client.execute(
            operation: "GetKnowledgeBase", 
            path: "/knowledgeBases/{knowledgeBaseId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the knowledge base.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getKnowledgeBase(
        knowledgeBaseId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetKnowledgeBaseResponse {
        let input = GetKnowledgeBaseRequest(
            knowledgeBaseId: knowledgeBaseId
        )
        return try await self.getKnowledgeBase(input, logger: logger)
    }

    /// Retrieves the Amazon Q in Connect message template. The message template identifier can contain an optional qualifier, for example, &lt;message-template-id&gt;:&lt;qualifier&gt;, which is either an actual version number or an Amazon Q Connect managed qualifier $ACTIVE_VERSION | $LATEST. If it is not supplied, then $LATEST is assumed implicitly.
    @Sendable
    @inlinable
    public func getMessageTemplate(_ input: GetMessageTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMessageTemplateResponse {
        try await self.client.execute(
            operation: "GetMessageTemplate", 
            path: "/knowledgeBases/{knowledgeBaseId}/messageTemplates/{messageTemplateId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the Amazon Q in Connect message template. The message template identifier can contain an optional qualifier, for example, &lt;message-template-id&gt;:&lt;qualifier&gt;, which is either an actual version number or an Amazon Q Connect managed qualifier $ACTIVE_VERSION | $LATEST. If it is not supplied, then $LATEST is assumed implicitly.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - messageTemplateId: The identifier of the message template. Can be either the ID or the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getMessageTemplate(
        knowledgeBaseId: String,
        messageTemplateId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMessageTemplateResponse {
        let input = GetMessageTemplateRequest(
            knowledgeBaseId: knowledgeBaseId, 
            messageTemplateId: messageTemplateId
        )
        return try await self.getMessageTemplate(input, logger: logger)
    }

    /// Retrieves next message on an Amazon Q in Connect session.
    @Sendable
    @inlinable
    public func getNextMessage(_ input: GetNextMessageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNextMessageResponse {
        try await self.client.execute(
            operation: "GetNextMessage", 
            path: "/assistants/{assistantId}/sessions/{sessionId}/messages/next", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves next message on an Amazon Q in Connect session.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant.
    ///   - nextMessageToken: The token for the next message. Use the value returned in the SendMessage or previous response in the next request to retrieve the next message.
    ///   - sessionId: The identifier of the Amazon Q in Connect session.
    ///   - logger: Logger use during operation
    @inlinable
    public func getNextMessage(
        assistantId: String,
        nextMessageToken: String,
        sessionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNextMessageResponse {
        let input = GetNextMessageRequest(
            assistantId: assistantId, 
            nextMessageToken: nextMessageToken, 
            sessionId: sessionId
        )
        return try await self.getNextMessage(input, logger: logger)
    }

    /// Retrieves the quick response.
    @Sendable
    @inlinable
    public func getQuickResponse(_ input: GetQuickResponseRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetQuickResponseResponse {
        try await self.client.execute(
            operation: "GetQuickResponse", 
            path: "/knowledgeBases/{knowledgeBaseId}/quickResponses/{quickResponseId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the quick response.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. This should be a QUICK_RESPONSES type knowledge base.
    ///   - quickResponseId: The identifier of the quick response.
    ///   - logger: Logger use during operation
    @inlinable
    public func getQuickResponse(
        knowledgeBaseId: String,
        quickResponseId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetQuickResponseResponse {
        let input = GetQuickResponseRequest(
            knowledgeBaseId: knowledgeBaseId, 
            quickResponseId: quickResponseId
        )
        return try await self.getQuickResponse(input, logger: logger)
    }

    ///  This API will be discontinued starting June 1, 2024. To receive generative responses after March 1, 2024, you will need to create a new Assistant in the Amazon Connect console and integrate the Amazon Q in Connect JavaScript library (amazon-q-connectjs) into your applications.  Retrieves recommendations for the specified session. To avoid retrieving the same recommendations in subsequent calls, use NotifyRecommendationsReceived. This API supports long-polling behavior with the waitTimeSeconds parameter. Short poll is the default behavior and only returns recommendations already available. To perform a manual query against an assistant, use QueryAssistant.
    @available(*, deprecated, message: "GetRecommendations API will be discontinued starting June 1, 2024. To receive generative responses after March 1, 2024 you will need to create a new Assistant in the Connect console and integrate the Amazon Q in Connect JavaScript library (amazon-q-connectjs) into your applications.")
    @Sendable
    @inlinable
    public func getRecommendations(_ input: GetRecommendationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRecommendationsResponse {
        try await self.client.execute(
            operation: "GetRecommendations", 
            path: "/assistants/{assistantId}/sessions/{sessionId}/recommendations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  This API will be discontinued starting June 1, 2024. To receive generative responses after March 1, 2024, you will need to create a new Assistant in the Amazon Connect console and integrate the Amazon Q in Connect JavaScript library (amazon-q-connectjs) into your applications.  Retrieves recommendations for the specified session. To avoid retrieving the same recommendations in subsequent calls, use NotifyRecommendationsReceived. This API supports long-polling behavior with the waitTimeSeconds parameter. Short poll is the default behavior and only returns recommendations already available. To perform a manual query against an assistant, use QueryAssistant.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextChunkToken: The token for the next set of chunks. Use the value returned in the previous response in the next request to retrieve the next set of chunks.
    ///   - sessionId: The identifier of the session. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - waitTimeSeconds: The duration (in seconds) for which the call waits for a recommendation to be made available before returning. If a recommendation is available, the call returns sooner than WaitTimeSeconds. If no messages are available and the wait time expires, the call returns successfully with an empty list.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "GetRecommendations API will be discontinued starting June 1, 2024. To receive generative responses after March 1, 2024 you will need to create a new Assistant in the Connect console and integrate the Amazon Q in Connect JavaScript library (amazon-q-connectjs) into your applications.")
    @inlinable
    public func getRecommendations(
        assistantId: String,
        maxResults: Int? = nil,
        nextChunkToken: String? = nil,
        sessionId: String,
        waitTimeSeconds: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRecommendationsResponse {
        let input = GetRecommendationsRequest(
            assistantId: assistantId, 
            maxResults: maxResults, 
            nextChunkToken: nextChunkToken, 
            sessionId: sessionId, 
            waitTimeSeconds: waitTimeSeconds
        )
        return try await self.getRecommendations(input, logger: logger)
    }

    /// Retrieves information for a specified session.
    @Sendable
    @inlinable
    public func getSession(_ input: GetSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSessionResponse {
        try await self.client.execute(
            operation: "GetSession", 
            path: "/assistants/{assistantId}/sessions/{sessionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information for a specified session.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - sessionId: The identifier of the session. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSession(
        assistantId: String,
        sessionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSessionResponse {
        let input = GetSessionRequest(
            assistantId: assistantId, 
            sessionId: sessionId
        )
        return try await self.getSession(input, logger: logger)
    }

    /// List AI Agent versions.
    @Sendable
    @inlinable
    public func listAIAgentVersions(_ input: ListAIAgentVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAIAgentVersionsResponse {
        try await self.client.execute(
            operation: "ListAIAgentVersions", 
            path: "/assistants/{assistantId}/aiagents/{aiAgentId}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List AI Agent versions.
    ///
    /// Parameters:
    ///   - aiAgentId: The identifier of the Amazon Q in Connect AI Agent for which versions are to be listed.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - origin: The origin of the AI Agent versions to be listed. SYSTEM for a default AI Agent created by Q in Connect or CUSTOMER for an AI Agent created by calling AI Agent creation APIs.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAIAgentVersions(
        aiAgentId: String,
        assistantId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        origin: Origin? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAIAgentVersionsResponse {
        let input = ListAIAgentVersionsRequest(
            aiAgentId: aiAgentId, 
            assistantId: assistantId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            origin: origin
        )
        return try await self.listAIAgentVersions(input, logger: logger)
    }

    /// Lists AI Agents.
    @Sendable
    @inlinable
    public func listAIAgents(_ input: ListAIAgentsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAIAgentsResponse {
        try await self.client.execute(
            operation: "ListAIAgents", 
            path: "/assistants/{assistantId}/aiagents", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists AI Agents.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - origin: The origin of the AI Agents to be listed. SYSTEM for a default AI Agent created by Q in Connect or CUSTOMER for an AI Agent created by calling AI Agent creation APIs.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAIAgents(
        assistantId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        origin: Origin? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAIAgentsResponse {
        let input = ListAIAgentsRequest(
            assistantId: assistantId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            origin: origin
        )
        return try await self.listAIAgents(input, logger: logger)
    }

    /// Lists AI Guardrail versions.
    @Sendable
    @inlinable
    public func listAIGuardrailVersions(_ input: ListAIGuardrailVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAIGuardrailVersionsResponse {
        try await self.client.execute(
            operation: "ListAIGuardrailVersions", 
            path: "/assistants/{assistantId}/aiguardrails/{aiGuardrailId}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists AI Guardrail versions.
    ///
    /// Parameters:
    ///   - aiGuardrailId: The identifier of the Amazon Q in Connect AI Guardrail for which versions are to be listed.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAIGuardrailVersions(
        aiGuardrailId: String,
        assistantId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAIGuardrailVersionsResponse {
        let input = ListAIGuardrailVersionsRequest(
            aiGuardrailId: aiGuardrailId, 
            assistantId: assistantId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAIGuardrailVersions(input, logger: logger)
    }

    /// Lists the AI Guardrails available on the Amazon Q in Connect assistant.
    @Sendable
    @inlinable
    public func listAIGuardrails(_ input: ListAIGuardrailsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAIGuardrailsResponse {
        try await self.client.execute(
            operation: "ListAIGuardrails", 
            path: "/assistants/{assistantId}/aiguardrails", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the AI Guardrails available on the Amazon Q in Connect assistant.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAIGuardrails(
        assistantId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAIGuardrailsResponse {
        let input = ListAIGuardrailsRequest(
            assistantId: assistantId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAIGuardrails(input, logger: logger)
    }

    /// Lists AI Prompt versions.
    @Sendable
    @inlinable
    public func listAIPromptVersions(_ input: ListAIPromptVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAIPromptVersionsResponse {
        try await self.client.execute(
            operation: "ListAIPromptVersions", 
            path: "/assistants/{assistantId}/aiprompts/{aiPromptId}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists AI Prompt versions.
    ///
    /// Parameters:
    ///   - aiPromptId: The identifier of the Amazon Q in Connect AI prompt for which versions are to be listed.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - origin: The origin of the AI Prompt versions to be listed. SYSTEM for a default AI Agent created by Q in Connect or CUSTOMER for an AI Agent created by calling AI Agent creation APIs.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAIPromptVersions(
        aiPromptId: String,
        assistantId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        origin: Origin? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAIPromptVersionsResponse {
        let input = ListAIPromptVersionsRequest(
            aiPromptId: aiPromptId, 
            assistantId: assistantId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            origin: origin
        )
        return try await self.listAIPromptVersions(input, logger: logger)
    }

    /// Lists the AI Prompts available on the Amazon Q in Connect assistant.
    @Sendable
    @inlinable
    public func listAIPrompts(_ input: ListAIPromptsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAIPromptsResponse {
        try await self.client.execute(
            operation: "ListAIPrompts", 
            path: "/assistants/{assistantId}/aiprompts", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the AI Prompts available on the Amazon Q in Connect assistant.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - origin: The origin of the AI Prompts to be listed. SYSTEM for a default AI Agent created by Q in Connect or CUSTOMER for an AI Agent created by calling AI Agent creation APIs.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAIPrompts(
        assistantId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        origin: Origin? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAIPromptsResponse {
        let input = ListAIPromptsRequest(
            assistantId: assistantId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            origin: origin
        )
        return try await self.listAIPrompts(input, logger: logger)
    }

    /// Lists information about assistant associations.
    @Sendable
    @inlinable
    public func listAssistantAssociations(_ input: ListAssistantAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAssistantAssociationsResponse {
        try await self.client.execute(
            operation: "ListAssistantAssociations", 
            path: "/assistants/{assistantId}/associations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists information about assistant associations.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAssistantAssociations(
        assistantId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAssistantAssociationsResponse {
        let input = ListAssistantAssociationsRequest(
            assistantId: assistantId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAssistantAssociations(input, logger: logger)
    }

    /// Lists information about assistants.
    @Sendable
    @inlinable
    public func listAssistants(_ input: ListAssistantsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAssistantsResponse {
        try await self.client.execute(
            operation: "ListAssistants", 
            path: "/assistants", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists information about assistants.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAssistants(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAssistantsResponse {
        let input = ListAssistantsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAssistants(input, logger: logger)
    }

    /// Lists the content associations. For more information about content associations--what they are and when they are used--see Integrate Amazon Q in Connect with step-by-step guides in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func listContentAssociations(_ input: ListContentAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListContentAssociationsResponse {
        try await self.client.execute(
            operation: "ListContentAssociations", 
            path: "/knowledgeBases/{knowledgeBaseId}/contents/{contentId}/associations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the content associations. For more information about content associations--what they are and when they are used--see Integrate Amazon Q in Connect with step-by-step guides in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - contentId: The identifier of the content.
    ///   - knowledgeBaseId: The identifier of the knowledge base.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listContentAssociations(
        contentId: String,
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListContentAssociationsResponse {
        let input = ListContentAssociationsRequest(
            contentId: contentId, 
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listContentAssociations(input, logger: logger)
    }

    /// Lists the content.
    @Sendable
    @inlinable
    public func listContents(_ input: ListContentsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListContentsResponse {
        try await self.client.execute(
            operation: "ListContents", 
            path: "/knowledgeBases/{knowledgeBaseId}/contents", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the content.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. This should not be a QUICK_RESPONSES type knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listContents(
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListContentsResponse {
        let input = ListContentsRequest(
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listContents(input, logger: logger)
    }

    /// Lists information about import jobs.
    @Sendable
    @inlinable
    public func listImportJobs(_ input: ListImportJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListImportJobsResponse {
        try await self.client.execute(
            operation: "ListImportJobs", 
            path: "/knowledgeBases/{knowledgeBaseId}/importJobs", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists information about import jobs.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listImportJobs(
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListImportJobsResponse {
        let input = ListImportJobsRequest(
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listImportJobs(input, logger: logger)
    }

    /// Lists the knowledge bases.
    @Sendable
    @inlinable
    public func listKnowledgeBases(_ input: ListKnowledgeBasesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListKnowledgeBasesResponse {
        try await self.client.execute(
            operation: "ListKnowledgeBases", 
            path: "/knowledgeBases", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the knowledge bases.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listKnowledgeBases(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListKnowledgeBasesResponse {
        let input = ListKnowledgeBasesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listKnowledgeBases(input, logger: logger)
    }

    /// Lists all the available versions for the specified Amazon Q in Connect message template.
    @Sendable
    @inlinable
    public func listMessageTemplateVersions(_ input: ListMessageTemplateVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMessageTemplateVersionsResponse {
        try await self.client.execute(
            operation: "ListMessageTemplateVersions", 
            path: "/knowledgeBases/{knowledgeBaseId}/messageTemplates/{messageTemplateId}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all the available versions for the specified Amazon Q in Connect message template.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - messageTemplateId: The identifier of the message template. Can be either the ID or the ARN. It cannot contain any qualifier.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMessageTemplateVersions(
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        messageTemplateId: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMessageTemplateVersionsResponse {
        let input = ListMessageTemplateVersionsRequest(
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults, 
            messageTemplateId: messageTemplateId, 
            nextToken: nextToken
        )
        return try await self.listMessageTemplateVersions(input, logger: logger)
    }

    /// Lists all the available Amazon Q in Connect message templates for the specified knowledge base.
    @Sendable
    @inlinable
    public func listMessageTemplates(_ input: ListMessageTemplatesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMessageTemplatesResponse {
        try await self.client.execute(
            operation: "ListMessageTemplates", 
            path: "/knowledgeBases/{knowledgeBaseId}/messageTemplates", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all the available Amazon Q in Connect message templates for the specified knowledge base.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMessageTemplates(
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMessageTemplatesResponse {
        let input = ListMessageTemplatesRequest(
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listMessageTemplates(input, logger: logger)
    }

    /// Lists messages on an Amazon Q in Connect session.
    @Sendable
    @inlinable
    public func listMessages(_ input: ListMessagesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMessagesResponse {
        try await self.client.execute(
            operation: "ListMessages", 
            path: "/assistants/{assistantId}/sessions/{sessionId}/messages", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists messages on an Amazon Q in Connect session.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - sessionId: The identifier of the Amazon Q in Connect session.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMessages(
        assistantId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        sessionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMessagesResponse {
        let input = ListMessagesRequest(
            assistantId: assistantId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            sessionId: sessionId
        )
        return try await self.listMessages(input, logger: logger)
    }

    /// Lists information about quick response.
    @Sendable
    @inlinable
    public func listQuickResponses(_ input: ListQuickResponsesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListQuickResponsesResponse {
        try await self.client.execute(
            operation: "ListQuickResponses", 
            path: "/knowledgeBases/{knowledgeBaseId}/quickResponses", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists information about quick response.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listQuickResponses(
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListQuickResponsesResponse {
        let input = ListQuickResponsesRequest(
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listQuickResponses(input, logger: logger)
    }

    /// Lists the tags for the specified resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the tags for the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Removes the specified recommendations from the specified assistant's queue of newly available recommendations. You can use this API in conjunction with GetRecommendations and a waitTimeSeconds input for long-polling behavior and avoiding duplicate recommendations.
    @Sendable
    @inlinable
    public func notifyRecommendationsReceived(_ input: NotifyRecommendationsReceivedRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> NotifyRecommendationsReceivedResponse {
        try await self.client.execute(
            operation: "NotifyRecommendationsReceived", 
            path: "/assistants/{assistantId}/sessions/{sessionId}/recommendations/notify", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the specified recommendations from the specified assistant's queue of newly available recommendations. You can use this API in conjunction with GetRecommendations and a waitTimeSeconds input for long-polling behavior and avoiding duplicate recommendations.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - recommendationIds: The identifiers of the recommendations.
    ///   - sessionId: The identifier of the session. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func notifyRecommendationsReceived(
        assistantId: String,
        recommendationIds: [String],
        sessionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> NotifyRecommendationsReceivedResponse {
        let input = NotifyRecommendationsReceivedRequest(
            assistantId: assistantId, 
            recommendationIds: recommendationIds, 
            sessionId: sessionId
        )
        return try await self.notifyRecommendationsReceived(input, logger: logger)
    }

    /// Provides feedback against the specified assistant for the specified target. This API only supports generative targets.
    @Sendable
    @inlinable
    public func putFeedback(_ input: PutFeedbackRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutFeedbackResponse {
        try await self.client.execute(
            operation: "PutFeedback", 
            path: "/assistants/{assistantId}/feedback", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides feedback against the specified assistant for the specified target. This API only supports generative targets.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant.
    ///   - contentFeedback: Information about the feedback provided.
    ///   - targetId: The identifier of the feedback target.
    ///   - targetType: The type of the feedback target.
    ///   - logger: Logger use during operation
    @inlinable
    public func putFeedback(
        assistantId: String,
        contentFeedback: ContentFeedbackData,
        targetId: String,
        targetType: TargetType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutFeedbackResponse {
        let input = PutFeedbackRequest(
            assistantId: assistantId, 
            contentFeedback: contentFeedback, 
            targetId: targetId, 
            targetType: targetType
        )
        return try await self.putFeedback(input, logger: logger)
    }

    ///  This API will be discontinued starting June 1, 2024. To receive generative responses after March 1, 2024, you will need to create a new Assistant in the Amazon Connect console and integrate the Amazon Q in Connect JavaScript library (amazon-q-connectjs) into your applications.  Performs a manual search against the specified assistant. To retrieve recommendations for an assistant, use GetRecommendations.
    @available(*, deprecated, message: "QueryAssistant API will be discontinued starting June 1, 2024. To receive generative responses after March 1, 2024 you will need to create a new Assistant in the Connect console and integrate the Amazon Q in Connect JavaScript library (amazon-q-connectjs) into your applications.")
    @Sendable
    @inlinable
    public func queryAssistant(_ input: QueryAssistantRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> QueryAssistantResponse {
        try await self.client.execute(
            operation: "QueryAssistant", 
            path: "/assistants/{assistantId}/query", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  This API will be discontinued starting June 1, 2024. To receive generative responses after March 1, 2024, you will need to create a new Assistant in the Amazon Connect console and integrate the Amazon Q in Connect JavaScript library (amazon-q-connectjs) into your applications.  Performs a manual search against the specified assistant. To retrieve recommendations for an assistant, use GetRecommendations.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - overrideKnowledgeBaseSearchType: The search type to be used against the Knowledge Base for this request. The values can be SEMANTIC which uses vector embeddings or HYBRID which use vector embeddings and raw text.
    ///   - queryCondition: Information about how to query content.
    ///   - queryInputData: Information about the query.
    ///   - queryText: The text to search for.
    ///   - sessionId: The identifier of the Amazon Q in Connect session. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "QueryAssistant API will be discontinued starting June 1, 2024. To receive generative responses after March 1, 2024 you will need to create a new Assistant in the Connect console and integrate the Amazon Q in Connect JavaScript library (amazon-q-connectjs) into your applications.")
    @inlinable
    public func queryAssistant(
        assistantId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        overrideKnowledgeBaseSearchType: KnowledgeBaseSearchType? = nil,
        queryCondition: [QueryCondition]? = nil,
        queryInputData: QueryInputData? = nil,
        queryText: String? = nil,
        sessionId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> QueryAssistantResponse {
        let input = QueryAssistantRequest(
            assistantId: assistantId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            overrideKnowledgeBaseSearchType: overrideKnowledgeBaseSearchType, 
            queryCondition: queryCondition, 
            queryInputData: queryInputData, 
            queryText: queryText, 
            sessionId: sessionId
        )
        return try await self.queryAssistant(input, logger: logger)
    }

    /// Removes the AI Agent that is set for use by default on an Amazon Q in Connect Assistant.
    @Sendable
    @inlinable
    public func removeAssistantAIAgent(_ input: RemoveAssistantAIAgentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RemoveAssistantAIAgentResponse {
        try await self.client.execute(
            operation: "RemoveAssistantAIAgent", 
            path: "/assistants/{assistantId}/aiagentConfiguration", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the AI Agent that is set for use by default on an Amazon Q in Connect Assistant.
    ///
    /// Parameters:
    ///   - aiAgentType: The type of the AI Agent being removed for use by default from the Amazon Q in Connect Assistant.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func removeAssistantAIAgent(
        aiAgentType: AIAgentType,
        assistantId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RemoveAssistantAIAgentResponse {
        let input = RemoveAssistantAIAgentRequest(
            aiAgentType: aiAgentType, 
            assistantId: assistantId
        )
        return try await self.removeAssistantAIAgent(input, logger: logger)
    }

    /// Removes a URI template from a knowledge base.
    @Sendable
    @inlinable
    public func removeKnowledgeBaseTemplateUri(_ input: RemoveKnowledgeBaseTemplateUriRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RemoveKnowledgeBaseTemplateUriResponse {
        try await self.client.execute(
            operation: "RemoveKnowledgeBaseTemplateUri", 
            path: "/knowledgeBases/{knowledgeBaseId}/templateUri", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes a URI template from a knowledge base.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func removeKnowledgeBaseTemplateUri(
        knowledgeBaseId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RemoveKnowledgeBaseTemplateUriResponse {
        let input = RemoveKnowledgeBaseTemplateUriRequest(
            knowledgeBaseId: knowledgeBaseId
        )
        return try await self.removeKnowledgeBaseTemplateUri(input, logger: logger)
    }

    /// Renders the Amazon Q in Connect message template based on the attribute values provided and generates the message content. For any variable present in the message template, if the attribute value is neither provided in the attribute request parameter nor the default attribute of the message template, the rendered message content will keep the variable placeholder as it is and return the attribute keys that are missing.
    @Sendable
    @inlinable
    public func renderMessageTemplate(_ input: RenderMessageTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RenderMessageTemplateResponse {
        try await self.client.execute(
            operation: "RenderMessageTemplate", 
            path: "/knowledgeBases/{knowledgeBaseId}/messageTemplates/{messageTemplateId}/render", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Renders the Amazon Q in Connect message template based on the attribute values provided and generates the message content. For any variable present in the message template, if the attribute value is neither provided in the attribute request parameter nor the default attribute of the message template, the rendered message content will keep the variable placeholder as it is and return the attribute keys that are missing.
    ///
    /// Parameters:
    ///   - attributes: An object that specifies the values to use for variables in the message template. This object contains different categories of key-value pairs. Each key defines a variable or placeholder in the message template. The corresponding value defines the value for that variable.
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - messageTemplateId: The identifier of the message template. Can be either the ID or the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func renderMessageTemplate(
        attributes: MessageTemplateAttributes,
        knowledgeBaseId: String,
        messageTemplateId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RenderMessageTemplateResponse {
        let input = RenderMessageTemplateRequest(
            attributes: attributes, 
            knowledgeBaseId: knowledgeBaseId, 
            messageTemplateId: messageTemplateId
        )
        return try await self.renderMessageTemplate(input, logger: logger)
    }

    /// Searches for content in a specified knowledge base. Can be used to get a specific content resource by its name.
    @Sendable
    @inlinable
    public func searchContent(_ input: SearchContentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchContentResponse {
        try await self.client.execute(
            operation: "SearchContent", 
            path: "/knowledgeBases/{knowledgeBaseId}/search", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for content in a specified knowledge base. Can be used to get a specific content resource by its name.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. This should not be a QUICK_RESPONSES type knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - searchExpression: The search expression to filter results.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchContent(
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchExpression: SearchExpression,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchContentResponse {
        let input = SearchContentRequest(
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchExpression: searchExpression
        )
        return try await self.searchContent(input, logger: logger)
    }

    /// Searches for Amazon Q in Connect message templates in the specified knowledge base.
    @Sendable
    @inlinable
    public func searchMessageTemplates(_ input: SearchMessageTemplatesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchMessageTemplatesResponse {
        try await self.client.execute(
            operation: "SearchMessageTemplates", 
            path: "/knowledgeBases/{knowledgeBaseId}/search/messageTemplates", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for Amazon Q in Connect message templates in the specified knowledge base.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - searchExpression: The search expression for querying the message template.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchMessageTemplates(
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchExpression: MessageTemplateSearchExpression,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchMessageTemplatesResponse {
        let input = SearchMessageTemplatesRequest(
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchExpression: searchExpression
        )
        return try await self.searchMessageTemplates(input, logger: logger)
    }

    /// Searches existing Amazon Q in Connect quick responses in an Amazon Q in Connect knowledge base.
    @Sendable
    @inlinable
    public func searchQuickResponses(_ input: SearchQuickResponsesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchQuickResponsesResponse {
        try await self.client.execute(
            operation: "SearchQuickResponses", 
            path: "/knowledgeBases/{knowledgeBaseId}/search/quickResponses", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches existing Amazon Q in Connect quick responses in an Amazon Q in Connect knowledge base.
    ///
    /// Parameters:
    ///   - attributes: The user-defined Amazon Connect contact attributes to be resolved when search results are returned.
    ///   - knowledgeBaseId: The identifier of the knowledge base. This should be a QUICK_RESPONSES type knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - searchExpression: The search expression for querying the quick response.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchQuickResponses(
        attributes: [String: String]? = nil,
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchExpression: QuickResponseSearchExpression,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchQuickResponsesResponse {
        let input = SearchQuickResponsesRequest(
            attributes: attributes, 
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchExpression: searchExpression
        )
        return try await self.searchQuickResponses(input, logger: logger)
    }

    /// Searches for sessions.
    @Sendable
    @inlinable
    public func searchSessions(_ input: SearchSessionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchSessionsResponse {
        try await self.client.execute(
            operation: "SearchSessions", 
            path: "/assistants/{assistantId}/searchSessions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for sessions.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - searchExpression: The search expression to filter results.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchSessions(
        assistantId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchExpression: SearchExpression,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchSessionsResponse {
        let input = SearchSessionsRequest(
            assistantId: assistantId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchExpression: searchExpression
        )
        return try await self.searchSessions(input, logger: logger)
    }

    /// Submits a message to the Amazon Q in Connect session.
    @Sendable
    @inlinable
    public func sendMessage(_ input: SendMessageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SendMessageResponse {
        try await self.client.execute(
            operation: "SendMessage", 
            path: "/assistants/{assistantId}/sessions/{sessionId}/message", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Submits a message to the Amazon Q in Connect session.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the AWS SDK populates this field.For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - configuration: The configuration of the SendMessage request.
    ///   - conversationContext: The conversation context before the Amazon Q in Connect session.
    ///   - message: The message data to submit to the Amazon Q in Connect session.
    ///   - sessionId: The identifier of the Amazon Q in Connect session.
    ///   - type: The message type.
    ///   - logger: Logger use during operation
    @inlinable
    public func sendMessage(
        assistantId: String,
        clientToken: String? = SendMessageRequest.idempotencyToken(),
        configuration: MessageConfiguration? = nil,
        conversationContext: ConversationContext? = nil,
        message: MessageInput,
        sessionId: String,
        type: MessageType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SendMessageResponse {
        let input = SendMessageRequest(
            assistantId: assistantId, 
            clientToken: clientToken, 
            configuration: configuration, 
            conversationContext: conversationContext, 
            message: message, 
            sessionId: sessionId, 
            type: type
        )
        return try await self.sendMessage(input, logger: logger)
    }

    /// Get a URL to upload content to a knowledge base. To upload content, first make a PUT request to the returned URL with your file, making sure to include the required headers. Then use CreateContent to finalize the content creation process or UpdateContent to modify an existing resource. You can only upload content to a knowledge base of type CUSTOM.
    @Sendable
    @inlinable
    public func startContentUpload(_ input: StartContentUploadRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartContentUploadResponse {
        try await self.client.execute(
            operation: "StartContentUpload", 
            path: "/knowledgeBases/{knowledgeBaseId}/upload", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get a URL to upload content to a knowledge base. To upload content, first make a PUT request to the returned URL with your file, making sure to include the required headers. Then use CreateContent to finalize the content creation process or UpdateContent to modify an existing resource. You can only upload content to a knowledge base of type CUSTOM.
    ///
    /// Parameters:
    ///   - contentType: The type of content to upload.
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - presignedUrlTimeToLive: The expected expiration time of the generated presigned URL, specified in minutes.
    ///   - logger: Logger use during operation
    @inlinable
    public func startContentUpload(
        contentType: String,
        knowledgeBaseId: String,
        presignedUrlTimeToLive: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartContentUploadResponse {
        let input = StartContentUploadRequest(
            contentType: contentType, 
            knowledgeBaseId: knowledgeBaseId, 
            presignedUrlTimeToLive: presignedUrlTimeToLive
        )
        return try await self.startContentUpload(input, logger: logger)
    }

    /// Start an asynchronous job to import Amazon Q in Connect resources from an uploaded source file. Before calling this API, use StartContentUpload to upload an asset that contains the resource data.   For importing Amazon Q in Connect quick responses, you need to upload a csv file including the quick responses. For information about how to format the csv file for importing quick responses, see Import quick responses.
    @Sendable
    @inlinable
    public func startImportJob(_ input: StartImportJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartImportJobResponse {
        try await self.client.execute(
            operation: "StartImportJob", 
            path: "/knowledgeBases/{knowledgeBaseId}/importJobs", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Start an asynchronous job to import Amazon Q in Connect resources from an uploaded source file. Before calling this API, use StartContentUpload to upload an asset that contains the resource data.   For importing Amazon Q in Connect quick responses, you need to upload a csv file including the quick responses. For information about how to format the csv file for importing quick responses, see Import quick responses.
    ///
    /// Parameters:
    ///   - clientToken: The tags used to organize, track, or control access for this resource.
    ///   - externalSourceConfiguration: The configuration information of the external source that the resource data are imported from.
    ///   - importJobType: The type of the import job.   For importing quick response resource, set the value to QUICK_RESPONSES.
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.   For importing Amazon Q in Connect quick responses, this should be a QUICK_RESPONSES type knowledge base.
    ///   - metadata: The metadata fields of the imported Amazon Q in Connect resources.
    ///   - uploadId: A pointer to the uploaded asset. This value is returned by StartContentUpload.
    ///   - logger: Logger use during operation
    @inlinable
    public func startImportJob(
        clientToken: String? = StartImportJobRequest.idempotencyToken(),
        externalSourceConfiguration: ExternalSourceConfiguration? = nil,
        importJobType: ImportJobType,
        knowledgeBaseId: String,
        metadata: [String: String]? = nil,
        uploadId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartImportJobResponse {
        let input = StartImportJobRequest(
            clientToken: clientToken, 
            externalSourceConfiguration: externalSourceConfiguration, 
            importJobType: importJobType, 
            knowledgeBaseId: knowledgeBaseId, 
            metadata: metadata, 
            uploadId: uploadId
        )
        return try await self.startImportJob(input, logger: logger)
    }

    /// Adds the specified tags to the specified resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds the specified tags to the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tags: The tags used to organize, track, or control access for this resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes the specified tags from the specified resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the specified tags from the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tagKeys: The tag keys.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates an AI Agent.
    @Sendable
    @inlinable
    public func updateAIAgent(_ input: UpdateAIAgentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAIAgentResponse {
        try await self.client.execute(
            operation: "UpdateAIAgent", 
            path: "/assistants/{assistantId}/aiagents/{aiAgentId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an AI Agent.
    ///
    /// Parameters:
    ///   - aiAgentId: The identifier of the Amazon Q in Connect AI Agent.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs..
    ///   - configuration: The configuration of the Amazon Q in Connect AI Agent.
    ///   - description: The description of the Amazon Q in Connect AI Agent.
    ///   - visibilityStatus: The visbility status of the Amazon Q in Connect AI Agent.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAIAgent(
        aiAgentId: String,
        assistantId: String,
        clientToken: String? = UpdateAIAgentRequest.idempotencyToken(),
        configuration: AIAgentConfiguration? = nil,
        description: String? = nil,
        visibilityStatus: VisibilityStatus,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAIAgentResponse {
        let input = UpdateAIAgentRequest(
            aiAgentId: aiAgentId, 
            assistantId: assistantId, 
            clientToken: clientToken, 
            configuration: configuration, 
            description: description, 
            visibilityStatus: visibilityStatus
        )
        return try await self.updateAIAgent(input, logger: logger)
    }

    /// Updates an AI Guardrail.
    @Sendable
    @inlinable
    public func updateAIGuardrail(_ input: UpdateAIGuardrailRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAIGuardrailResponse {
        try await self.client.execute(
            operation: "UpdateAIGuardrail", 
            path: "/assistants/{assistantId}/aiguardrails/{aiGuardrailId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an AI Guardrail.
    ///
    /// Parameters:
    ///   - aiGuardrailId: The identifier of the Amazon Q in Connect AI Guardrail.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - blockedInputMessaging: The message to return when the AI Guardrail blocks a prompt.
    ///   - blockedOutputsMessaging: The message to return when the AI Guardrail blocks a model response.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs..
    ///   - contentPolicyConfig: The content filter policies to configure for the AI Guardrail.
    ///   - contextualGroundingPolicyConfig: The contextual grounding policy configuration used to create an AI Guardrail.
    ///   - description: A description of the AI Guardrail.
    ///   - sensitiveInformationPolicyConfig: The sensitive information policy to configure for the AI Guardrail.
    ///   - topicPolicyConfig: The topic policies to configure for the AI Guardrail.
    ///   - visibilityStatus: The visibility status of the Amazon Q in Connect AI Guardrail.
    ///   - wordPolicyConfig: The word policy you configure for the AI Guardrail.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAIGuardrail(
        aiGuardrailId: String,
        assistantId: String,
        blockedInputMessaging: String,
        blockedOutputsMessaging: String,
        clientToken: String? = UpdateAIGuardrailRequest.idempotencyToken(),
        contentPolicyConfig: AIGuardrailContentPolicyConfig? = nil,
        contextualGroundingPolicyConfig: AIGuardrailContextualGroundingPolicyConfig? = nil,
        description: String? = nil,
        sensitiveInformationPolicyConfig: AIGuardrailSensitiveInformationPolicyConfig? = nil,
        topicPolicyConfig: AIGuardrailTopicPolicyConfig? = nil,
        visibilityStatus: VisibilityStatus,
        wordPolicyConfig: AIGuardrailWordPolicyConfig? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAIGuardrailResponse {
        let input = UpdateAIGuardrailRequest(
            aiGuardrailId: aiGuardrailId, 
            assistantId: assistantId, 
            blockedInputMessaging: blockedInputMessaging, 
            blockedOutputsMessaging: blockedOutputsMessaging, 
            clientToken: clientToken, 
            contentPolicyConfig: contentPolicyConfig, 
            contextualGroundingPolicyConfig: contextualGroundingPolicyConfig, 
            description: description, 
            sensitiveInformationPolicyConfig: sensitiveInformationPolicyConfig, 
            topicPolicyConfig: topicPolicyConfig, 
            visibilityStatus: visibilityStatus, 
            wordPolicyConfig: wordPolicyConfig
        )
        return try await self.updateAIGuardrail(input, logger: logger)
    }

    /// Updates an AI Prompt.
    @Sendable
    @inlinable
    public func updateAIPrompt(_ input: UpdateAIPromptRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAIPromptResponse {
        try await self.client.execute(
            operation: "UpdateAIPrompt", 
            path: "/assistants/{assistantId}/aiprompts/{aiPromptId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an AI Prompt.
    ///
    /// Parameters:
    ///   - aiPromptId: The identifier of the Amazon Q in Connect AI Prompt.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs..
    ///   - description: The description of the Amazon Q in Connect AI Prompt.
    ///   - templateConfiguration: The configuration of the prompt template for this AI Prompt.
    ///   - visibilityStatus: The visibility status of the Amazon Q in Connect AI prompt.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAIPrompt(
        aiPromptId: String,
        assistantId: String,
        clientToken: String? = UpdateAIPromptRequest.idempotencyToken(),
        description: String? = nil,
        templateConfiguration: AIPromptTemplateConfiguration? = nil,
        visibilityStatus: VisibilityStatus,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAIPromptResponse {
        let input = UpdateAIPromptRequest(
            aiPromptId: aiPromptId, 
            assistantId: assistantId, 
            clientToken: clientToken, 
            description: description, 
            templateConfiguration: templateConfiguration, 
            visibilityStatus: visibilityStatus
        )
        return try await self.updateAIPrompt(input, logger: logger)
    }

    /// Updates the AI Agent that is set for use by default on an Amazon Q in Connect Assistant.
    @Sendable
    @inlinable
    public func updateAssistantAIAgent(_ input: UpdateAssistantAIAgentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAssistantAIAgentResponse {
        try await self.client.execute(
            operation: "UpdateAssistantAIAgent", 
            path: "/assistants/{assistantId}/aiagentConfiguration", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the AI Agent that is set for use by default on an Amazon Q in Connect Assistant.
    ///
    /// Parameters:
    ///   - aiAgentType: The type of the AI Agent being updated for use by default on the Amazon Q in Connect Assistant.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - configuration: The configuration of the AI Agent being updated for use by default on the Amazon Q in Connect Assistant.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAssistantAIAgent(
        aiAgentType: AIAgentType,
        assistantId: String,
        configuration: AIAgentConfigurationData,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAssistantAIAgentResponse {
        let input = UpdateAssistantAIAgentRequest(
            aiAgentType: aiAgentType, 
            assistantId: assistantId, 
            configuration: configuration
        )
        return try await self.updateAssistantAIAgent(input, logger: logger)
    }

    /// Updates information about the content.
    @Sendable
    @inlinable
    public func updateContent(_ input: UpdateContentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateContentResponse {
        try await self.client.execute(
            operation: "UpdateContent", 
            path: "/knowledgeBases/{knowledgeBaseId}/contents/{contentId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates information about the content.
    ///
    /// Parameters:
    ///   - contentId: The identifier of the content. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - knowledgeBaseId: The identifier of the knowledge base. This should not be a QUICK_RESPONSES type knowledge base. Can be either the ID or the ARN
    ///   - metadata: A key/value map to store attributes without affecting tagging or recommendations. For example, when synchronizing data between an external system and Amazon Q in Connect, you can store an external version identifier as metadata to utilize for determining drift.
    ///   - overrideLinkOutUri: The URI for the article. If the knowledge base has a templateUri, setting this argument overrides it for this piece of content. To remove an existing overrideLinkOurUri, exclude this argument and set removeOverrideLinkOutUri to true.
    ///   - removeOverrideLinkOutUri: Unset the existing overrideLinkOutUri if it exists.
    ///   - revisionId: The revisionId of the content resource to update, taken from an earlier call to GetContent, GetContentSummary, SearchContent, or ListContents. If included, this argument acts as an optimistic lock to ensure content was not modified since it was last read. If it has been modified, this API throws a PreconditionFailedException.
    ///   - title: The title of the content.
    ///   - uploadId: A pointer to the uploaded asset. This value is returned by StartContentUpload.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateContent(
        contentId: String,
        knowledgeBaseId: String,
        metadata: [String: String]? = nil,
        overrideLinkOutUri: String? = nil,
        removeOverrideLinkOutUri: Bool? = nil,
        revisionId: String? = nil,
        title: String? = nil,
        uploadId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateContentResponse {
        let input = UpdateContentRequest(
            contentId: contentId, 
            knowledgeBaseId: knowledgeBaseId, 
            metadata: metadata, 
            overrideLinkOutUri: overrideLinkOutUri, 
            removeOverrideLinkOutUri: removeOverrideLinkOutUri, 
            revisionId: revisionId, 
            title: title, 
            uploadId: uploadId
        )
        return try await self.updateContent(input, logger: logger)
    }

    /// Updates the template URI of a knowledge base. This is only supported for knowledge bases of type EXTERNAL. Include a single variable in ${variable} format; this interpolated by Amazon Q in Connect using ingested content. For example, if you ingest a Salesforce article, it has an Id value, and you can set the template URI to https://myInstanceName.lightning.force.com/lightning/r/Knowledge__kav/*${Id}*/view.
    @Sendable
    @inlinable
    public func updateKnowledgeBaseTemplateUri(_ input: UpdateKnowledgeBaseTemplateUriRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateKnowledgeBaseTemplateUriResponse {
        try await self.client.execute(
            operation: "UpdateKnowledgeBaseTemplateUri", 
            path: "/knowledgeBases/{knowledgeBaseId}/templateUri", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the template URI of a knowledge base. This is only supported for knowledge bases of type EXTERNAL. Include a single variable in ${variable} format; this interpolated by Amazon Q in Connect using ingested content. For example, if you ingest a Salesforce article, it has an Id value, and you can set the template URI to https://myInstanceName.lightning.force.com/lightning/r/Knowledge__kav/*${Id}*/view.
    ///
    /// Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. This should not be a QUICK_RESPONSES type knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - templateUri: The template URI to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateKnowledgeBaseTemplateUri(
        knowledgeBaseId: String,
        templateUri: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateKnowledgeBaseTemplateUriResponse {
        let input = UpdateKnowledgeBaseTemplateUriRequest(
            knowledgeBaseId: knowledgeBaseId, 
            templateUri: templateUri
        )
        return try await self.updateKnowledgeBaseTemplateUri(input, logger: logger)
    }

    /// Updates the Amazon Q in Connect message template. Partial update is supported. If any field is not supplied, it will remain unchanged for the message template that is referenced by the $LATEST qualifier. Any modification will only apply to the message template that is referenced by the $LATEST qualifier. The fields for all available versions will remain unchanged.
    @Sendable
    @inlinable
    public func updateMessageTemplate(_ input: UpdateMessageTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateMessageTemplateResponse {
        try await self.client.execute(
            operation: "UpdateMessageTemplate", 
            path: "/knowledgeBases/{knowledgeBaseId}/messageTemplates/{messageTemplateId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the Amazon Q in Connect message template. Partial update is supported. If any field is not supplied, it will remain unchanged for the message template that is referenced by the $LATEST qualifier. Any modification will only apply to the message template that is referenced by the $LATEST qualifier. The fields for all available versions will remain unchanged.
    ///
    /// Parameters:
    ///   - content: The content of the message template.
    ///   - defaultAttributes: An object that specifies the default values to use for variables in the message template. This object contains different categories of key-value pairs. Each key defines a variable or placeholder in the message template. The corresponding value defines the default value for that variable.
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - language: The language code value for the language in which the quick response is written. The supported language codes include de_DE, en_US, es_ES, fr_FR, id_ID, it_IT, ja_JP, ko_KR, pt_BR, zh_CN, zh_TW
    ///   - messageTemplateId: The identifier of the message template. Can be either the ID or the ARN. It cannot contain any qualifier.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateMessageTemplate(
        content: MessageTemplateContentProvider? = nil,
        defaultAttributes: MessageTemplateAttributes? = nil,
        knowledgeBaseId: String,
        language: String? = nil,
        messageTemplateId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateMessageTemplateResponse {
        let input = UpdateMessageTemplateRequest(
            content: content, 
            defaultAttributes: defaultAttributes, 
            knowledgeBaseId: knowledgeBaseId, 
            language: language, 
            messageTemplateId: messageTemplateId
        )
        return try await self.updateMessageTemplate(input, logger: logger)
    }

    /// Updates the Amazon Q in Connect message template metadata. Note that any modification to the message template’s name, description and grouping configuration will applied to the message template pointed by the $LATEST qualifier and all available versions. Partial update is supported. If any field is not supplied, it will remain unchanged for the message template.
    @Sendable
    @inlinable
    public func updateMessageTemplateMetadata(_ input: UpdateMessageTemplateMetadataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateMessageTemplateMetadataResponse {
        try await self.client.execute(
            operation: "UpdateMessageTemplateMetadata", 
            path: "/knowledgeBases/{knowledgeBaseId}/messageTemplates/{messageTemplateId}/metadata", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the Amazon Q in Connect message template metadata. Note that any modification to the message template’s name, description and grouping configuration will applied to the message template pointed by the $LATEST qualifier and all available versions. Partial update is supported. If any field is not supplied, it will remain unchanged for the message template.
    ///
    /// Parameters:
    ///   - description: The description of the message template.
    ///   - groupingConfiguration: 
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - messageTemplateId: The identifier of the message template. Can be either the ID or the ARN. It cannot contain any qualifier.
    ///   - name: The name of the message template.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateMessageTemplateMetadata(
        description: String? = nil,
        groupingConfiguration: GroupingConfiguration? = nil,
        knowledgeBaseId: String,
        messageTemplateId: String,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateMessageTemplateMetadataResponse {
        let input = UpdateMessageTemplateMetadataRequest(
            description: description, 
            groupingConfiguration: groupingConfiguration, 
            knowledgeBaseId: knowledgeBaseId, 
            messageTemplateId: messageTemplateId, 
            name: name
        )
        return try await self.updateMessageTemplateMetadata(input, logger: logger)
    }

    /// Updates an existing Amazon Q in Connect quick response.
    @Sendable
    @inlinable
    public func updateQuickResponse(_ input: UpdateQuickResponseRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateQuickResponseResponse {
        try await self.client.execute(
            operation: "UpdateQuickResponse", 
            path: "/knowledgeBases/{knowledgeBaseId}/quickResponses/{quickResponseId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing Amazon Q in Connect quick response.
    ///
    /// Parameters:
    ///   - channels: The Amazon Connect contact channels this quick response applies to. The supported contact channel types include Chat.
    ///   - content: The updated content of the quick response.
    ///   - contentType: The media type of the quick response content.   Use application/x.quickresponse;format=plain for quick response written in plain text.   Use application/x.quickresponse;format=markdown for quick response written in richtext.
    ///   - description: The updated description of the quick response.
    ///   - groupingConfiguration: The updated grouping configuration of the quick response.
    ///   - isActive: Whether the quick response is active.
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - language: The language code value for the language in which the quick response is written. The supported language codes include de_DE, en_US, es_ES, fr_FR, id_ID, it_IT, ja_JP, ko_KR, pt_BR, zh_CN, zh_TW
    ///   - name: The name of the quick response.
    ///   - quickResponseId: The identifier of the quick response.
    ///   - removeDescription: Whether to remove the description from the quick response.
    ///   - removeGroupingConfiguration: Whether to remove the grouping configuration of the quick response.
    ///   - removeShortcutKey: Whether to remove the shortcut key of the quick response.
    ///   - shortcutKey: The shortcut key of the quick response. The value should be unique across the knowledge base.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateQuickResponse(
        channels: [String]? = nil,
        content: QuickResponseDataProvider? = nil,
        contentType: String? = nil,
        description: String? = nil,
        groupingConfiguration: GroupingConfiguration? = nil,
        isActive: Bool? = nil,
        knowledgeBaseId: String,
        language: String? = nil,
        name: String? = nil,
        quickResponseId: String,
        removeDescription: Bool? = nil,
        removeGroupingConfiguration: Bool? = nil,
        removeShortcutKey: Bool? = nil,
        shortcutKey: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateQuickResponseResponse {
        let input = UpdateQuickResponseRequest(
            channels: channels, 
            content: content, 
            contentType: contentType, 
            description: description, 
            groupingConfiguration: groupingConfiguration, 
            isActive: isActive, 
            knowledgeBaseId: knowledgeBaseId, 
            language: language, 
            name: name, 
            quickResponseId: quickResponseId, 
            removeDescription: removeDescription, 
            removeGroupingConfiguration: removeGroupingConfiguration, 
            removeShortcutKey: removeShortcutKey, 
            shortcutKey: shortcutKey
        )
        return try await self.updateQuickResponse(input, logger: logger)
    }

    /// Updates a session. A session is a contextual container used for generating recommendations. Amazon Connect updates the existing Amazon Q in Connect session for each contact on which Amazon Q in Connect is enabled.
    @Sendable
    @inlinable
    public func updateSession(_ input: UpdateSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSessionResponse {
        try await self.client.execute(
            operation: "UpdateSession", 
            path: "/assistants/{assistantId}/sessions/{sessionId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a session. A session is a contextual container used for generating recommendations. Amazon Connect updates the existing Amazon Q in Connect session for each contact on which Amazon Q in Connect is enabled.
    ///
    /// Parameters:
    ///   - aiAgentConfiguration: The configuration of the AI Agents (mapped by AI Agent Type to AI Agent version) that should be used by Amazon Q in Connect for this Session.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - description: The description.
    ///   - sessionId: The identifier of the session. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - tagFilter: An object that can be used to specify Tag conditions.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSession(
        aiAgentConfiguration: [AIAgentType: AIAgentConfigurationData]? = nil,
        assistantId: String,
        description: String? = nil,
        sessionId: String,
        tagFilter: TagFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSessionResponse {
        let input = UpdateSessionRequest(
            aiAgentConfiguration: aiAgentConfiguration, 
            assistantId: assistantId, 
            description: description, 
            sessionId: sessionId, 
            tagFilter: tagFilter
        )
        return try await self.updateSession(input, logger: logger)
    }

    /// Updates the data stored on an Amazon Q in Connect Session.
    @Sendable
    @inlinable
    public func updateSessionData(_ input: UpdateSessionDataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSessionDataResponse {
        try await self.client.execute(
            operation: "UpdateSessionData", 
            path: "/assistants/{assistantId}/sessions/{sessionId}/data", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the data stored on an Amazon Q in Connect Session.
    ///
    /// Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - data: The data stored on the Amazon Q in Connect Session.
    ///   - namespace: The namespace into which the session data is stored. Supported namespaces are: Custom
    ///   - sessionId: The identifier of the session. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSessionData(
        assistantId: String,
        data: [RuntimeSessionData],
        namespace: SessionDataNamespace? = nil,
        sessionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSessionDataResponse {
        let input = UpdateSessionDataRequest(
            assistantId: assistantId, 
            data: data, 
            namespace: namespace, 
            sessionId: sessionId
        )
        return try await self.updateSessionData(input, logger: logger)
    }
}

extension QConnect {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: QConnect, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension QConnect {
    /// Return PaginatorSequence for operation ``listAIAgentVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAIAgentVersionsPaginator(
        _ input: ListAIAgentVersionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAIAgentVersionsRequest, ListAIAgentVersionsResponse> {
        return .init(
            input: input,
            command: self.listAIAgentVersions,
            inputKey: \ListAIAgentVersionsRequest.nextToken,
            outputKey: \ListAIAgentVersionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAIAgentVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - aiAgentId: The identifier of the Amazon Q in Connect AI Agent for which versions are to be listed.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - origin: The origin of the AI Agent versions to be listed. SYSTEM for a default AI Agent created by Q in Connect or CUSTOMER for an AI Agent created by calling AI Agent creation APIs.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAIAgentVersionsPaginator(
        aiAgentId: String,
        assistantId: String,
        maxResults: Int? = nil,
        origin: Origin? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAIAgentVersionsRequest, ListAIAgentVersionsResponse> {
        let input = ListAIAgentVersionsRequest(
            aiAgentId: aiAgentId, 
            assistantId: assistantId, 
            maxResults: maxResults, 
            origin: origin
        )
        return self.listAIAgentVersionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAIAgents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAIAgentsPaginator(
        _ input: ListAIAgentsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAIAgentsRequest, ListAIAgentsResponse> {
        return .init(
            input: input,
            command: self.listAIAgents,
            inputKey: \ListAIAgentsRequest.nextToken,
            outputKey: \ListAIAgentsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAIAgents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - origin: The origin of the AI Agents to be listed. SYSTEM for a default AI Agent created by Q in Connect or CUSTOMER for an AI Agent created by calling AI Agent creation APIs.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAIAgentsPaginator(
        assistantId: String,
        maxResults: Int? = nil,
        origin: Origin? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAIAgentsRequest, ListAIAgentsResponse> {
        let input = ListAIAgentsRequest(
            assistantId: assistantId, 
            maxResults: maxResults, 
            origin: origin
        )
        return self.listAIAgentsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAIGuardrailVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAIGuardrailVersionsPaginator(
        _ input: ListAIGuardrailVersionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAIGuardrailVersionsRequest, ListAIGuardrailVersionsResponse> {
        return .init(
            input: input,
            command: self.listAIGuardrailVersions,
            inputKey: \ListAIGuardrailVersionsRequest.nextToken,
            outputKey: \ListAIGuardrailVersionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAIGuardrailVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - aiGuardrailId: The identifier of the Amazon Q in Connect AI Guardrail for which versions are to be listed.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAIGuardrailVersionsPaginator(
        aiGuardrailId: String,
        assistantId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAIGuardrailVersionsRequest, ListAIGuardrailVersionsResponse> {
        let input = ListAIGuardrailVersionsRequest(
            aiGuardrailId: aiGuardrailId, 
            assistantId: assistantId, 
            maxResults: maxResults
        )
        return self.listAIGuardrailVersionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAIGuardrails(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAIGuardrailsPaginator(
        _ input: ListAIGuardrailsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAIGuardrailsRequest, ListAIGuardrailsResponse> {
        return .init(
            input: input,
            command: self.listAIGuardrails,
            inputKey: \ListAIGuardrailsRequest.nextToken,
            outputKey: \ListAIGuardrailsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAIGuardrails(_:logger:)``.
    ///
    /// - Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAIGuardrailsPaginator(
        assistantId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAIGuardrailsRequest, ListAIGuardrailsResponse> {
        let input = ListAIGuardrailsRequest(
            assistantId: assistantId, 
            maxResults: maxResults
        )
        return self.listAIGuardrailsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAIPromptVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAIPromptVersionsPaginator(
        _ input: ListAIPromptVersionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAIPromptVersionsRequest, ListAIPromptVersionsResponse> {
        return .init(
            input: input,
            command: self.listAIPromptVersions,
            inputKey: \ListAIPromptVersionsRequest.nextToken,
            outputKey: \ListAIPromptVersionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAIPromptVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - aiPromptId: The identifier of the Amazon Q in Connect AI prompt for which versions are to be listed.
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - origin: The origin of the AI Prompt versions to be listed. SYSTEM for a default AI Agent created by Q in Connect or CUSTOMER for an AI Agent created by calling AI Agent creation APIs.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAIPromptVersionsPaginator(
        aiPromptId: String,
        assistantId: String,
        maxResults: Int? = nil,
        origin: Origin? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAIPromptVersionsRequest, ListAIPromptVersionsResponse> {
        let input = ListAIPromptVersionsRequest(
            aiPromptId: aiPromptId, 
            assistantId: assistantId, 
            maxResults: maxResults, 
            origin: origin
        )
        return self.listAIPromptVersionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAIPrompts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAIPromptsPaginator(
        _ input: ListAIPromptsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAIPromptsRequest, ListAIPromptsResponse> {
        return .init(
            input: input,
            command: self.listAIPrompts,
            inputKey: \ListAIPromptsRequest.nextToken,
            outputKey: \ListAIPromptsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAIPrompts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - origin: The origin of the AI Prompts to be listed. SYSTEM for a default AI Agent created by Q in Connect or CUSTOMER for an AI Agent created by calling AI Agent creation APIs.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAIPromptsPaginator(
        assistantId: String,
        maxResults: Int? = nil,
        origin: Origin? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAIPromptsRequest, ListAIPromptsResponse> {
        let input = ListAIPromptsRequest(
            assistantId: assistantId, 
            maxResults: maxResults, 
            origin: origin
        )
        return self.listAIPromptsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAssistantAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssistantAssociationsPaginator(
        _ input: ListAssistantAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAssistantAssociationsRequest, ListAssistantAssociationsResponse> {
        return .init(
            input: input,
            command: self.listAssistantAssociations,
            inputKey: \ListAssistantAssociationsRequest.nextToken,
            outputKey: \ListAssistantAssociationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAssistantAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssistantAssociationsPaginator(
        assistantId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAssistantAssociationsRequest, ListAssistantAssociationsResponse> {
        let input = ListAssistantAssociationsRequest(
            assistantId: assistantId, 
            maxResults: maxResults
        )
        return self.listAssistantAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAssistants(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssistantsPaginator(
        _ input: ListAssistantsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAssistantsRequest, ListAssistantsResponse> {
        return .init(
            input: input,
            command: self.listAssistants,
            inputKey: \ListAssistantsRequest.nextToken,
            outputKey: \ListAssistantsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAssistants(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssistantsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAssistantsRequest, ListAssistantsResponse> {
        let input = ListAssistantsRequest(
            maxResults: maxResults
        )
        return self.listAssistantsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listContentAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listContentAssociationsPaginator(
        _ input: ListContentAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListContentAssociationsRequest, ListContentAssociationsResponse> {
        return .init(
            input: input,
            command: self.listContentAssociations,
            inputKey: \ListContentAssociationsRequest.nextToken,
            outputKey: \ListContentAssociationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listContentAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - contentId: The identifier of the content.
    ///   - knowledgeBaseId: The identifier of the knowledge base.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listContentAssociationsPaginator(
        contentId: String,
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListContentAssociationsRequest, ListContentAssociationsResponse> {
        let input = ListContentAssociationsRequest(
            contentId: contentId, 
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults
        )
        return self.listContentAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listContents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listContentsPaginator(
        _ input: ListContentsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListContentsRequest, ListContentsResponse> {
        return .init(
            input: input,
            command: self.listContents,
            inputKey: \ListContentsRequest.nextToken,
            outputKey: \ListContentsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listContents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. This should not be a QUICK_RESPONSES type knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listContentsPaginator(
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListContentsRequest, ListContentsResponse> {
        let input = ListContentsRequest(
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults
        )
        return self.listContentsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listImportJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listImportJobsPaginator(
        _ input: ListImportJobsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListImportJobsRequest, ListImportJobsResponse> {
        return .init(
            input: input,
            command: self.listImportJobs,
            inputKey: \ListImportJobsRequest.nextToken,
            outputKey: \ListImportJobsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listImportJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listImportJobsPaginator(
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListImportJobsRequest, ListImportJobsResponse> {
        let input = ListImportJobsRequest(
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults
        )
        return self.listImportJobsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listKnowledgeBases(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listKnowledgeBasesPaginator(
        _ input: ListKnowledgeBasesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListKnowledgeBasesRequest, ListKnowledgeBasesResponse> {
        return .init(
            input: input,
            command: self.listKnowledgeBases,
            inputKey: \ListKnowledgeBasesRequest.nextToken,
            outputKey: \ListKnowledgeBasesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listKnowledgeBases(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listKnowledgeBasesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListKnowledgeBasesRequest, ListKnowledgeBasesResponse> {
        let input = ListKnowledgeBasesRequest(
            maxResults: maxResults
        )
        return self.listKnowledgeBasesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMessageTemplateVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMessageTemplateVersionsPaginator(
        _ input: ListMessageTemplateVersionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMessageTemplateVersionsRequest, ListMessageTemplateVersionsResponse> {
        return .init(
            input: input,
            command: self.listMessageTemplateVersions,
            inputKey: \ListMessageTemplateVersionsRequest.nextToken,
            outputKey: \ListMessageTemplateVersionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMessageTemplateVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - messageTemplateId: The identifier of the message template. Can be either the ID or the ARN. It cannot contain any qualifier.
    ///   - logger: Logger used for logging
    @inlinable
    public func listMessageTemplateVersionsPaginator(
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        messageTemplateId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMessageTemplateVersionsRequest, ListMessageTemplateVersionsResponse> {
        let input = ListMessageTemplateVersionsRequest(
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults, 
            messageTemplateId: messageTemplateId
        )
        return self.listMessageTemplateVersionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMessageTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMessageTemplatesPaginator(
        _ input: ListMessageTemplatesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMessageTemplatesRequest, ListMessageTemplatesResponse> {
        return .init(
            input: input,
            command: self.listMessageTemplates,
            inputKey: \ListMessageTemplatesRequest.nextToken,
            outputKey: \ListMessageTemplatesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMessageTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listMessageTemplatesPaginator(
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMessageTemplatesRequest, ListMessageTemplatesResponse> {
        let input = ListMessageTemplatesRequest(
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults
        )
        return self.listMessageTemplatesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMessages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMessagesPaginator(
        _ input: ListMessagesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMessagesRequest, ListMessagesResponse> {
        return .init(
            input: input,
            command: self.listMessages,
            inputKey: \ListMessagesRequest.nextToken,
            outputKey: \ListMessagesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMessages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - sessionId: The identifier of the Amazon Q in Connect session.
    ///   - logger: Logger used for logging
    @inlinable
    public func listMessagesPaginator(
        assistantId: String,
        maxResults: Int? = nil,
        sessionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMessagesRequest, ListMessagesResponse> {
        let input = ListMessagesRequest(
            assistantId: assistantId, 
            maxResults: maxResults, 
            sessionId: sessionId
        )
        return self.listMessagesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listQuickResponses(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listQuickResponsesPaginator(
        _ input: ListQuickResponsesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListQuickResponsesRequest, ListQuickResponsesResponse> {
        return .init(
            input: input,
            command: self.listQuickResponses,
            inputKey: \ListQuickResponsesRequest.nextToken,
            outputKey: \ListQuickResponsesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listQuickResponses(_:logger:)``.
    ///
    /// - Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listQuickResponsesPaginator(
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListQuickResponsesRequest, ListQuickResponsesResponse> {
        let input = ListQuickResponsesRequest(
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults
        )
        return self.listQuickResponsesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``queryAssistant(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "QueryAssistant API will be discontinued starting June 1, 2024. To receive generative responses after March 1, 2024 you will need to create a new Assistant in the Connect console and integrate the Amazon Q in Connect JavaScript library (amazon-q-connectjs) into your applications.")
    @inlinable
    public func queryAssistantPaginator(
        _ input: QueryAssistantRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<QueryAssistantRequest, QueryAssistantResponse> {
        return .init(
            input: input,
            command: self.queryAssistant,
            inputKey: \QueryAssistantRequest.nextToken,
            outputKey: \QueryAssistantResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``queryAssistant(_:logger:)``.
    ///
    /// - Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - overrideKnowledgeBaseSearchType: The search type to be used against the Knowledge Base for this request. The values can be SEMANTIC which uses vector embeddings or HYBRID which use vector embeddings and raw text.
    ///   - queryCondition: Information about how to query content.
    ///   - queryInputData: Information about the query.
    ///   - queryText: The text to search for.
    ///   - sessionId: The identifier of the Amazon Q in Connect session. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "QueryAssistant API will be discontinued starting June 1, 2024. To receive generative responses after March 1, 2024 you will need to create a new Assistant in the Connect console and integrate the Amazon Q in Connect JavaScript library (amazon-q-connectjs) into your applications.")
    @inlinable
    public func queryAssistantPaginator(
        assistantId: String,
        maxResults: Int? = nil,
        overrideKnowledgeBaseSearchType: KnowledgeBaseSearchType? = nil,
        queryCondition: [QueryCondition]? = nil,
        queryInputData: QueryInputData? = nil,
        queryText: String? = nil,
        sessionId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<QueryAssistantRequest, QueryAssistantResponse> {
        let input = QueryAssistantRequest(
            assistantId: assistantId, 
            maxResults: maxResults, 
            overrideKnowledgeBaseSearchType: overrideKnowledgeBaseSearchType, 
            queryCondition: queryCondition, 
            queryInputData: queryInputData, 
            queryText: queryText, 
            sessionId: sessionId
        )
        return self.queryAssistantPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchContent(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchContentPaginator(
        _ input: SearchContentRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchContentRequest, SearchContentResponse> {
        return .init(
            input: input,
            command: self.searchContent,
            inputKey: \SearchContentRequest.nextToken,
            outputKey: \SearchContentResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchContent(_:logger:)``.
    ///
    /// - Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. This should not be a QUICK_RESPONSES type knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - searchExpression: The search expression to filter results.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchContentPaginator(
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        searchExpression: SearchExpression,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchContentRequest, SearchContentResponse> {
        let input = SearchContentRequest(
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults, 
            searchExpression: searchExpression
        )
        return self.searchContentPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchMessageTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchMessageTemplatesPaginator(
        _ input: SearchMessageTemplatesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchMessageTemplatesRequest, SearchMessageTemplatesResponse> {
        return .init(
            input: input,
            command: self.searchMessageTemplates,
            inputKey: \SearchMessageTemplatesRequest.nextToken,
            outputKey: \SearchMessageTemplatesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchMessageTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - knowledgeBaseId: The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - searchExpression: The search expression for querying the message template.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchMessageTemplatesPaginator(
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        searchExpression: MessageTemplateSearchExpression,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchMessageTemplatesRequest, SearchMessageTemplatesResponse> {
        let input = SearchMessageTemplatesRequest(
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults, 
            searchExpression: searchExpression
        )
        return self.searchMessageTemplatesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchQuickResponses(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchQuickResponsesPaginator(
        _ input: SearchQuickResponsesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchQuickResponsesRequest, SearchQuickResponsesResponse> {
        return .init(
            input: input,
            command: self.searchQuickResponses,
            inputKey: \SearchQuickResponsesRequest.nextToken,
            outputKey: \SearchQuickResponsesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchQuickResponses(_:logger:)``.
    ///
    /// - Parameters:
    ///   - attributes: The user-defined Amazon Connect contact attributes to be resolved when search results are returned.
    ///   - knowledgeBaseId: The identifier of the knowledge base. This should be a QUICK_RESPONSES type knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - searchExpression: The search expression for querying the quick response.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchQuickResponsesPaginator(
        attributes: [String: String]? = nil,
        knowledgeBaseId: String,
        maxResults: Int? = nil,
        searchExpression: QuickResponseSearchExpression,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchQuickResponsesRequest, SearchQuickResponsesResponse> {
        let input = SearchQuickResponsesRequest(
            attributes: attributes, 
            knowledgeBaseId: knowledgeBaseId, 
            maxResults: maxResults, 
            searchExpression: searchExpression
        )
        return self.searchQuickResponsesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchSessions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchSessionsPaginator(
        _ input: SearchSessionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchSessionsRequest, SearchSessionsResponse> {
        return .init(
            input: input,
            command: self.searchSessions,
            inputKey: \SearchSessionsRequest.nextToken,
            outputKey: \SearchSessionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchSessions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - assistantId: The identifier of the Amazon Q in Connect assistant. Can be either the ID or the ARN. URLs cannot contain the ARN.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - searchExpression: The search expression to filter results.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchSessionsPaginator(
        assistantId: String,
        maxResults: Int? = nil,
        searchExpression: SearchExpression,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchSessionsRequest, SearchSessionsResponse> {
        let input = SearchSessionsRequest(
            assistantId: assistantId, 
            maxResults: maxResults, 
            searchExpression: searchExpression
        )
        return self.searchSessionsPaginator(input, logger: logger)
    }
}

extension QConnect.ListAIAgentVersionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.ListAIAgentVersionsRequest {
        return .init(
            aiAgentId: self.aiAgentId,
            assistantId: self.assistantId,
            maxResults: self.maxResults,
            nextToken: token,
            origin: self.origin
        )
    }
}

extension QConnect.ListAIAgentsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.ListAIAgentsRequest {
        return .init(
            assistantId: self.assistantId,
            maxResults: self.maxResults,
            nextToken: token,
            origin: self.origin
        )
    }
}

extension QConnect.ListAIGuardrailVersionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.ListAIGuardrailVersionsRequest {
        return .init(
            aiGuardrailId: self.aiGuardrailId,
            assistantId: self.assistantId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QConnect.ListAIGuardrailsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.ListAIGuardrailsRequest {
        return .init(
            assistantId: self.assistantId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QConnect.ListAIPromptVersionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.ListAIPromptVersionsRequest {
        return .init(
            aiPromptId: self.aiPromptId,
            assistantId: self.assistantId,
            maxResults: self.maxResults,
            nextToken: token,
            origin: self.origin
        )
    }
}

extension QConnect.ListAIPromptsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.ListAIPromptsRequest {
        return .init(
            assistantId: self.assistantId,
            maxResults: self.maxResults,
            nextToken: token,
            origin: self.origin
        )
    }
}

extension QConnect.ListAssistantAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.ListAssistantAssociationsRequest {
        return .init(
            assistantId: self.assistantId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QConnect.ListAssistantsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.ListAssistantsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QConnect.ListContentAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.ListContentAssociationsRequest {
        return .init(
            contentId: self.contentId,
            knowledgeBaseId: self.knowledgeBaseId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QConnect.ListContentsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.ListContentsRequest {
        return .init(
            knowledgeBaseId: self.knowledgeBaseId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QConnect.ListImportJobsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.ListImportJobsRequest {
        return .init(
            knowledgeBaseId: self.knowledgeBaseId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QConnect.ListKnowledgeBasesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.ListKnowledgeBasesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QConnect.ListMessageTemplateVersionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.ListMessageTemplateVersionsRequest {
        return .init(
            knowledgeBaseId: self.knowledgeBaseId,
            maxResults: self.maxResults,
            messageTemplateId: self.messageTemplateId,
            nextToken: token
        )
    }
}

extension QConnect.ListMessageTemplatesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.ListMessageTemplatesRequest {
        return .init(
            knowledgeBaseId: self.knowledgeBaseId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QConnect.ListMessagesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.ListMessagesRequest {
        return .init(
            assistantId: self.assistantId,
            maxResults: self.maxResults,
            nextToken: token,
            sessionId: self.sessionId
        )
    }
}

extension QConnect.ListQuickResponsesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.ListQuickResponsesRequest {
        return .init(
            knowledgeBaseId: self.knowledgeBaseId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QConnect.QueryAssistantRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.QueryAssistantRequest {
        return .init(
            assistantId: self.assistantId,
            maxResults: self.maxResults,
            nextToken: token,
            overrideKnowledgeBaseSearchType: self.overrideKnowledgeBaseSearchType,
            queryCondition: self.queryCondition,
            queryInputData: self.queryInputData,
            queryText: self.queryText,
            sessionId: self.sessionId
        )
    }
}

extension QConnect.SearchContentRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.SearchContentRequest {
        return .init(
            knowledgeBaseId: self.knowledgeBaseId,
            maxResults: self.maxResults,
            nextToken: token,
            searchExpression: self.searchExpression
        )
    }
}

extension QConnect.SearchMessageTemplatesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.SearchMessageTemplatesRequest {
        return .init(
            knowledgeBaseId: self.knowledgeBaseId,
            maxResults: self.maxResults,
            nextToken: token,
            searchExpression: self.searchExpression
        )
    }
}

extension QConnect.SearchQuickResponsesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.SearchQuickResponsesRequest {
        return .init(
            attributes: self.attributes,
            knowledgeBaseId: self.knowledgeBaseId,
            maxResults: self.maxResults,
            nextToken: token,
            searchExpression: self.searchExpression
        )
    }
}

extension QConnect.SearchSessionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QConnect.SearchSessionsRequest {
        return .init(
            assistantId: self.assistantId,
            maxResults: self.maxResults,
            nextToken: token,
            searchExpression: self.searchExpression
        )
    }
}
